Wordbler女士-可爱的小莺!（译文）

原文地址：https://www.codeproject.com/Articles/1284591/Ms-Wordbler-A-Cute-Little-Warbler

原文作者：Mehedi Shams

译文由本站 robot-v1.0 翻译

前言

Word-making game!

文字游戏!

• 下载Wordbler_Project.zip-3 MB(Download Wordbler_Project.zip - 3 MB)
• 下载Wordbler.zip-3.6 MB(Download Wordbler.zip - 3.6 MB)

介绍(Introduction)

这是一个造词游戏;这是带有.NET Framework 4.5.2的C#.NET中的Winforms项目.使用的IDE是Visual Studio 2017.(This is a word-making game; this is a Winforms project in C#.NET with .NET framework 4.5.2. IDE used was Visual Studio 2017.) 该应用程序构建为与分辨率无关.设计时分辨率为1680x1050.经过测试,分辨率为1366x768\1280x720\800x600.经过测试还可以,但是图形质量会降低(如预期的那样).(The application is built to be resolution independent. Design-time resolution was 1680x1050. It is tested with resolutions of 1366x768, 1280x720, 800x600. Tested okay, however graphics quality degrades with lower resolution (as expected).) 字母,图块,单元格–文章中所有这些元素均可互换使用;他们的意思是一样的.(Letter, tile, cell – all are used interchangeably in the article; they mean the same.)

背景(Background)

世界各地有各种填字游戏,包括填字游戏.这是从其中一些借来的.目的是对逻辑开发进行实验,以了解如何实际考虑数据结构和算法以及如何在字符串中找到结构模式.这纯粹是出于教育目的,其中包含一些乐趣.(There are various word-making games including crosswording logic around the world. This one borrows some ideas from some of them. The purpose is to experiment on logic development about how to practically think of data structures and algorithms and how to find structural patterns in strings. This is purely for educational purposes with some fun inside it.)

游戏如何运作(How the Game Works)

• 游戏开始时要求玩家人数.最多可能有4位玩家和至少2位玩家.玩家需要输入名称并选择吉祥物(将吉祥物拖放到各个吉祥物框中).(The game starts with asking for the number of players. There may be at best 4 players and at least 2 players. Players need to enter their names and choose mascots (drag and drop mascots in the individual mascot boxes).)

• 接下来确定哪个玩家开始游戏.每个玩家从包中随机分配一个字母.如果有玩家获得空白牌,则他/他开始游戏.否则,最接近字母" A"的玩家将开始游戏.在确定第一个玩家之后,所有字母将返回到包中.(Which player starts the game is decided next. Each player is randomly distributed one letter from the bag. If any player gets a blank tile, then s/he starts the game. Else the player whose letter is closest to ‘A’ will start the game. After the first player is decided, all the letters are returned to the bag.)

• 接下来,在架子上从袋子中装入7个随机字母.(Next the racks are loaded with 7 random letters from the bag.)

• 玩家将单个字母拖放到板上.第一个单词必须穿过中心星().(A Player drags and drops individual letters on the board. The first word must cross through the central star () tile.)

• 玩家认为单词已完成后,请按"完成"按钮.此时,将出现一个带有评分详细信息的消息框.如果所有创造的单词都有效,则他/她得分.否则,这些字母将被带回他/她的架子并转向下一位玩家.(After the player thinks the word is complete, s/he presses the DONE button. At this point, a messagebox appears with scoring details. If all coined words are valid, then s/he scores. Else the letters are taken back to his/her rack and turn moves to the next player.)

• 转弯移动到下一个玩家(顺时针),游戏将继续进行.(Turn moves to the next player (clockwise) and the game is carried on as such.)

• 玩家可以交换书包中任意数量的字母.交流被他/她拒绝.要进行交换,请按住CTRL键并单击要交换的字母(图块变成深红色),然后按EXCHANGE键.(A player can exchange any number of letters from the bag. An exchange forfeits his/her current turn. To exchange, hold the CTRL button and click on the letters to exchange (the tile turns into crimson colour), then press the EXCHANGE button.)

• 如果玩家一言不发就可以放弃回合.但这并不需要,因为如果单词无效,游戏会自动放弃当前回合.(A player can forfeit a turn if s/he can’t make a word. This is not needed though, as the game automatically forfeits the current turn if the word is not valid.)

• 如果玩家拖动空白图块,则应在将其放置在板上时设置图块值.瓷砖单元可以用粉红色识别.在其余的游戏中,该值保持不变.但是,图块将始终带有0分.(If a player drags a blank tile, the tile value should be set when it is dropped on the board. The tile cell could be identified by pink colour. The value remains like that for the rest of the game. However, the tile will always carry a 0-score.)

• 如果制作的有效字词跨过高级单元格(2W,2L,3W,3L),则在对这些特殊图块进行评分后,它们将成为常规图块-以后不会再增加通过它们的任何单词.这是通过将其特殊的背景颜色更改为灰色来表示的.(If a valid word is made that crosses through premium cells (2W, 2L, 3W, 3L), then after the scoring those special tiles become regular tiles – they will not augment any future words that pass through them. This is signified by changing their special background colour to grey.)

• 如果玩家错误地将字母丢在棋盘的错误单元格上,他/他可以通过按CTRL + Z将其取回.对于当前回合,玩家可以根据需要多次按CTRL + Z.这将使字母以相反的拖动顺序返回机架.(If a player mistakenly drops a letter on a wrong cell of the board, s/he can take it back by pressing CTRL+Z. For the current turn, the player can press CTRL+Z as many times as needed. This will take the letters back to the rack in reverse order of dragging.)

• 在任何时候,连续6次失败(错误的单词,没收,交换)将结束游戏.在这种情况下,每个玩家机架中剩余字母的面值总和将从其总得分中扣除.(At any point, 6 consecutive fails (wrong word, forfeit, exchange) will end the game. In that case, summation of the face-values of the remaining letters in each player’s rack is deducted from his/her total score.)

• 如果袋子里没有字母了,那么(If there is no more letter in the bag, then)

  • 如果其中一位玩家可以使用他/她的所有字母,则将其他玩家的字母总和添加到他的分数中,并从他们的分数中扣除.(If one of the players could use all his/her letters, then the sum of other players’ letters is added to his score and deducted from theirs.)
  • 将每个玩家机架中剩余字母的其他面值相加,然后将每个玩家的得分减去个人总和.(Else face-values of the remaining letters in each player’s rack are summed up and each player’s score is deducted by the individual sum.)

• 单词的扩展形式是允许的.例如,如果玩家输入单词" END".然后另一位玩家可以将其扩展到" ENDINGS",另一位玩家可以将其扩展到" ENDINGS".都是有效的单词.(Extended forms of a word are allowed. For example, if a player makes a word ‘END’. then another player can extend it to ‘ENDING’, another player can extend it to ‘ENDINGS’. All are valid words.)

• 之后,得分最高的玩家将赢得比赛.(After that, the player with the highest score wins the game.)

项目结构概览(A Glimpse of the Project Structure)

形式(Forms)

选择播放器(SelectPlayer)

这是游戏的启动表格.它与主要逻辑没有太大关系.它只是为游戏增添了一点魅力.(This is the start-up form for the game. It doesn’t have to do much with the main logic. It just adds a little glamour touch to the game.)

在这种形式下,玩家需要输入他们的名字并将吉祥物拖到他们的吉祥物盒子中.(In this form, the players need to enter their name and drag a mascot to their mascot boxes.)

Wordbler(Wordbler)

这是玩游戏的主要形式.它容纳了棋盘,架子,球员的名字,图例,失败计数,吉祥物,得分和按钮.(This is the main form where the game is played. It accommodates the board, the racks, player’s names, legends, fail counts, mascots, scores and buttons.) 加载后,该表格会显示所有可用的玩家架子.字母袋摇动并随机地将字母分发给每个玩家.这封信决定了哪个玩家应该开始游戏.提醒一下,画一个最接近" A"的字母或画一个空白方块的玩家开始游戏.(On loading, the form displays all the available players’ racks. The letter bag shakes and distributes a letter randomly to each of the players. The letter decides which player should start the game. To remind, the player who draws a letter closest to ‘A’, or draws a blank tile starts the game.) 在确定第一个玩家后,将字母打包,然后将7个字母随机分配给每个玩家.起始播放器的机架已启用,其他已禁用.玩家将字母拖到板上.(After the first player is decided the letters are taken bag and then 7 letters are randomly distributed to each of the players. The rack of the starting player is enabled, and others are disabled. The player drags the letters on the board.)

一共有三个按钮-“完成”,“交换"和"通过”.如果玩家想提交得分单词,则他/他按"完成".如果玩家想交换字母,则他/他按"交换"(进行交换,需要在按住CTRL键的同时单击字母来选择字母).如果玩家决定通过,则按" Pass".(There are three buttons – ‘Done’, ‘Exchange’, and ‘Pass’. If the player wants to submit the word for scoring, then s/he presses ‘Done’. If the player wants to exchange letters, then s/he presses ‘Exchange’ (for exchanging, the letters need to be selected by clicking on the letters while holding the CTRL-key down). If a player decides to pass, s/he presses ‘Pass’.) 使用菜单,图例可以显示或隐藏.根据切换,隐藏或显示高级内容(3L,2L,3W,2W).(Using the menu, the legends can be visible or hidden. The premium contents (3L, 2L, 3W, 2W) are hidden or displayed according to toggle.)

游戏继续进行.(The game moves on with turns.)

WildCardChooser(WildCardChooser)

当玩家在板上拖动通配符(由兰花色瓷砖指定)时,将显示此表格,并要求用户为其选择字母.如果措词成功,则通配符会将该字母保留在面板上.但是,通配符带有0点,直到游戏结束,该点始终为0.通配符将由粉红色识别.(When the player drags the wildcard (designated by the orchid-colour tile) on the board, this form shows up and asks the user to choose a letter for it. If the wording is successful, then the wildcard retains that letter on the board. However, a wildcard carries 0-point which will always be 0 till the end of the game. The wild card will be identified by the pink-colour.)

DisplayScoreDetails(DisplayScoreDetails)

当玩家单击任何吉祥物时,此表格将显示拥有该吉祥物的玩家的得分历史.它遍历详细的历史记录,并按轮流显示它.(When a player clicks on any mascot, this form displays the scoring history of the player who owns the mascot. It loops through the detailed history and displays it according to turns.)

关于(About)

“关于"框-显示有关项目的信息.(The ‘About’ box – displays information about the project.)

班级(Classes)

全球(Globals)

包含项目的不同模块所需的全局和静态变量.(Contains global and static variables needed by different modules of the project.)

BoardCell(BoardCell)

包含放置字母的板单元的(X,Y)坐标.它还包含有关Boad-cell丢弃之前可能具有的任何高级内容(2W,3W,2L,3L)的信息.它包含放在单元格上的字母.这些属性是通过构造函数填充的.(Contains the (X, Y) coordinate of the board-cell where a letter is dropped. It also contains information about any premium content (2W, 3W, 2L, 3L) that boad-cell might have before the drop. It contains the letter that was dropped on the cell. These properties are populated through the constructor.)

机架式电池(RackCell)

当玩家开始从机架中拖动字母时,保留机架单元的详细信息.它记录玩家编号,单元编号和该单元上的字母.这些属性是通过复制构造函数,常规构造函数和"添加"方法填充的.(Holds the details of a rack cell when the player starts dragging a letter from the rack. It records the player number, the cell number and the letter that was on that cell. These properties are populated through a copy constructor, a regular constructor and an ‘Add’ method.)

信件(Letter)

持有一封信及其立场.该字母可以是交换字母,抽签字母或包装袋中的字母.位置是书包中字母的索引.这两个属性是通过构造函数填充的.(Holds a letter and its position. The letter might be an exchanging letter, a drawn letter, or a letter in the bag. The position is the index of the letter in the bag. These two properties are populated through the constructor.)

个人分数(IndividualScore)

此类包含对单词的每个字母评分的机制.它包含字母,字母在董事会上的轴,董事会可能拥有的所有高级内容(2W,3W,2L,3L)以及得分.字母具有根据预定义规则的面值.(This class contains the mechanism for scoring each individual letter of a word. It contains the letter, the axis of the letter on the board, any premium content (2W, 3W, 2L, 3L) the board might have, and the score for the letter. The letters have their face-value according to pre-defined rules.)

ValidWordWithScore(ValidWordWithScore)

包含当前回合中创造的整个单词,以及该单词的各个字母得分详细信息(使用”(Contains the whole word that was coined in the current turn, individual letter score details of the word (using a list of ‘) IndividualScore ’object),此单词开始的板上的轴.(’ object), the axis on the board where this word started.)

TurnsWithScores(TurnsWithScores)

包含转弯编号,详细得分(这是按"完成"按钮时显示的消息的准确副本)以及该转弯的有效字词.所有属性都通过构造函数填充.(Contains turn number, detailed score (which is an exact copy of the message that is displayed when ‘Done’ button is pressed), and valid words of the turn. All the properties are populated through constructor.)

玩家详情(PlayerDetails)

包含球员的详细信息(姓名,吉祥物),他们的总得分和历史得分详细信息(使用"(Contains details of the players (name, mascot), their total score and their historical scoring details (using the ‘) TurnsWithScores ’对象).名称和吉祥物通过构造函数填充.总得分和历史得分的详细信息是公共属性,因此通过对象实例进行填充.(’ object) of the current game. Name and mascot are populated through constructors.  Total score and historical score details are public properties – hence populated through the object instance.)

窗口缩放器(WindowScaler)

此类有助于根据不同的屏幕分辨率自动调整表单元素的大小.游戏与分辨率无关;此类包含为此目的的核心计算.此类的详细说明超出了本文的范围.请参阅(This class facilitates the automatic resizing of the elements of the forms according to different screen resolutions. The game is resolution-independent; this class contains the core calculation for the purpose. The detailed explanation for this class is beyond the scope of this article. Please refer to) 这里(here) .(.)

游戏板设计(Game Board Design)

板子的每个控件都基于0命名,以避免混淆.(Every control of the board is named 0-based to avoid any confusion.)

架子(Racks)

对于播放器1,有7个图块,基本上是7个标签控件.这些磁贴放置在面板控件中.(For player 1, there are 7 tiles which are basically 7 label controls. These tiles are placed inside a panel control.) 它们分别命名为p0l0,p0l1…. p0l6. " p"代表"玩家"," l"代表标签.基于0的索引被用作命名约定,该约定提供了映射好处,将在后面讨论.(These are named as p0l0, p0l1 …. p0l6. ‘p’ is for ‘player’, ‘l’ is for label. 0-based indexing is used as the naming convention which provides mapping benefits that will be discussed later.) 类似地,为其他玩家命名.例如:p1l0,p1l1等.(Similarly tiles for other players are named. E.g.: p1l0, p1l1 etc.) 有4个面板可容纳4个播放器,所有播放器均具有7x4 =28个标签控件.(There are 4 panels for 4 players, and 7x4 = 28 label controls for all the players.)

板(Board)

该板的设计如下.(The board is designed in the following manner.) 从左到右移动视为X轴,从上到下移动称为Y轴.这也是基于0的,它还提供了映射好处,将在后面讨论.(Moving from left to right is treated as X-axis, moving from top to bottom is the Y-axis. This is also 0-based which also provides mapping benefits that will be discussed later.) 对于第一行,按以下方式设计标签. " l"代表标签.(For the first row, the labels are designed in the following manner. ‘l’ is for label.) l0_0,l1_0,l2_0,…….. l14_0.(l0_0, l1_0, l2_0, …….. l14_0.)

这样命名的目的是每个标签映射到矩阵中的相应单元格.例如,l4_12对应于矩阵中的单元格[4,12].值得一提的是,矩阵是验证单词的实际计算手段.(The intention of such naming is each label maps to the corresponding cell in the matrix. For example, l4_12 corresponds to the cell [4,12] in the matrix. It is worthwhile mentioning that, the matrix is the actual calculative means to validate the words.)

加载(显示)播放器(Loading (Showing) Players)

该设计将所有四个角色都设置到位.最初它们都是隐藏的.只是可视性逻辑会根据玩家数量显示它们.这是在"(The design has all the four players in place; initially they are all hidden. It is just the visibility logic that displays them according to the number of players. This is done in the ‘) LoadPlayers ' 方法.它遍历所有可用的播放器((’ method. It loops through all the available players () Players.Count ),并使其相应的架子,吉祥物和得分控件可见.() and makes their corresponding rack, mascot and score controls visible.)

Control ctl;
for (int i = 0; i < Players.Count; i++)
{
    ctl = Controls.Find($"rack{i}", true)[0]; // E.g.: rack0.
    ctl.Visible = true;
……………………………………………..
……………………………………………..

解决第一个玩家(Resolving First Player)

通过从每个玩家的书包中随机抽取一个字母来确定第一个玩家.它被加载到每个玩家机架的第一个单元上.绘制最接近" A"的字母或绘制空白图块的玩家将开始游戏.这是在"(The first player is decided by randomly drawing a letter from the bag for each player. It is loaded on the first cell of each player’s rack. The player who draws a letter closest to ‘A’, or draws a blank tile, will start the game. This is done in the ‘) ResolveFirstPlayer ' 方法.(’ method.) 以下部分首先检查是否有人绘制了空白图块.如果有人画了一个空白的方块,那么它只是从这里返回玩家编号.他/她将是第一位玩家.(The following segment first checks if anybody has drawn a blank tile. If anybody draws a blank tile, then it simply returns from here with the player number. S/he will be the first player.)

// If any player draws a blank tile, s/he will be the first to start.
// Visibility confirms if the player is available. Just to remind, if 3 players were to play,
// then p3l0 will not be visible, hence will be out of context and consideration.

if (p0l0.Visible && string.IsNullOrEmpty(p0l0.Text))
    return 0;
if (p1l0.Visible && string.IsNullOrEmpty(p1l0.Text))
    return 1;
if (p2l0.Visible && string.IsNullOrEmpty(p2l0.Text))
    return 2;
if (p3l0.Visible && string.IsNullOrEmpty(p3l0.Text))
    return 3;

如果没有人画一个空白的图块,那么下一步就是确定谁画了一个最接近" A"的字母.这很简单–只需确定距离并确定哪一个是最低的即可.(If nobody draws a blank tile, then the next step is to decide who draws a letter closest to ‘A’. This is simple – just take the distances and decide which one is the lowest.) 我们从一个较高的值(999)开始.最大距离可能是(Z-A)=25.因此,大于25的任何数字都应这样做.这是一种简单的算术运算法则-将小于上述距离的任何距离指定为当前最小值.最终获得距离最小的玩家.这是一次扫描,因此为O(n).(We start with a higher value (999). The maximum distance might be (Z-A) = 25. So, any number above 25 should do. It is a simple arithmetic – any distance that is lower than the preceding is assigned as the current minimum. Eventually the player with the minimum distance is obtained. This is a single sweep, hence is O(n).)

int min = 999, distance;                       // Start with a higher number.
int minWinner = -1;                            // Any number other than 0,1,2,3 will do.

for (int i = 0; i < Players.Count; i++)        // Loop through all players.
{
    ctl = Controls.Find($"p{i}l0", true)[0];   // E.g.: p2l0.
    distance = ctl.Text.ToCharArray()[0] - 'A';

    if (distance < min)        // E.g.: if text of p2l0 is 'E', then distance is 4.
    {
        min = distance;        // then make min the current distance,
        minWinner = i;         // and change the minWinner to the current player.
    }
}

如果有多个玩家画的字母最接近" A",则顺时针转数最早的那个字母将赢得比赛.(If more than one player draws the same letter that is closest to ‘A’, then the one who is earliest in the clockwise turn wins the toss.)

激活/停用玩家(Activating/Deactivating Players)

这很简单–遍历所有播放器,激活当前播放器,然后停用其他播放器.玩家编号作为参数传递.仅此播放器将被启用,其他播放器将被禁用.(This is simple – just loop through all the players, activate the current player and deactivate others. The player number is passed as the parameter. Only this player will be enabled, others will be disabled.) 这是通过"(This is accomplished through the ‘) ActivateDeactivatePlayers ' 方法.如果当前播放器是当前循环变量,则通过布尔检查来切换启用和可见性.(’ method. The enabling and visibility is toggled through the Boolean check if the current player is the current loop variable.)

private void ActivateDeactivatePlayers(int player)
{
    ……………………………………………..
    ……………………………………………..
    // Loop through all players.
    for (int i = 0; i < Players.Count; i++)
    {
        ……………………………………………..
        ……………………………………………..
        // If current player's turn, then enable name and rack.
        rackCtl.Enabled = scoreCtl.Enabled = i == player;

        // And make the green button visible.
        turnButtonCtl.Visible = i == player;
    }

无论如何,这可能只是一个陈述,只是为了理解而将它们分开.否则,这可能很简单:(This can be a single statement anyway, just separated them for understanding. Otherwise this could be as simple as:)

for (int i = 0; i < Players.Count; i++)
{
    ……………………………………………..
    ……………………………………………..
    rackCtl.Enabled = scoreCtl.Enabled = turnButtonCtl.Visible = i == player;
}

在袋子里装信件(Loading Letters in Bag)

袋子中每个字母的数量根据预先定义的规则确定.例如,袋子中应该恰好有4个" D" –不多也不少.这是通过在65(ASCII为" A")到90(ASCII为" Z")之间循环来实现的.对于每个ASCII值,会将相应的字母顺序添加到字母袋中.请注意,在游戏中随机选择它们时,它们是否顺序是无关紧要的.(The number of each letter in the bag is decided according to pre-defined rules. For example, there should be exactly 4 ‘D’s in the bag – no more, no less. This is accomplished by looping through 65 (ASCII for ‘A’) to 90 (ASCII for ‘Z’). For each ASCII value, the corresponding letter is added to the letter bag sequentially. To remind, it doesn’t matter at this point whether they are sequential or not as they are picked randomly during the game.) 在最后两个索引中手动添加了两个空白图块.(The two blank tiles are manually added in the last two indices.)

public void LoadLetterBag()
{
    for (int letter = 65, i = 0; letter < 91; letter++)
        switch (letter)
        {
            case 65:    // Should be 9 'A'
                for (int count = 0; count < 9; count++)
                    LetterBag[i++] = (char)letter;
                break;
            case 66:    // Should be 2 'B'
            case 67:    // Should be 2 'C'
            case 70:    // Should be 2 'F'
            case 72:    // Should be 2 'H'
            case 77:    // Should be 2 'M'
            case 80:    // Should be 2 'P'
            case 86:    // Should be 2 'V'
            case 87:    // Should be 2 'W'
            case 89:    // Should be 2 'Y'
                for (int count = 0; count < 2; count++)
                     LetterBag[i++] = (char)letter;
                break;
            ……………………………………………..
            ……………………………………………..
            ……………………………………………..
        }
    LetterBag[98] = LetterBag[99] = ' ';        // Two blank tiles.
}

在架子上装信件(Loading Letters in Racks)

通过从包中随机挑选字母来装载字母("(Letters are loaded through random letter picking from the bag (the ‘) LetterBag 数组).获得随机索引.如果该索引中的字母为空(\ 0),则循环继续,并获得另一个索引.(’ array). A random index is obtained. If the letter in that index is null (‘\0’), then the loop continues, and another index is obtained.)

private void LoadSingleLetter(int player, int cellNum)
{
    ………………………….
    ………………………….
    while (true)
    {
        index = Rnd.Next(0, NUM_LETTERS_IN_BAG);
        c = LetterBag[index];
        if (c == '\0')
            continue;
    ………………………….
    ………………………….
    LetterBag[index] = '\0';    // The letter at the index is taken. Hence make it empty.
    break;
    }
}

可能注意到(It might be noted that) Rnd.Next() 具有下限包含和上限排除.就是说,随机化器比给定的上限少一个.我们的100个字母的数组的下限为0,上限为100((has the lower bound inclusive and the upper bound exclusive. That means, the randomizer picks up to one less than the upper bound given to it. Our 100-letter array has the lower bound 0 and upper bound 100 () NUM_LETTERS_IN_BAG );因此,随机化器正确选择0到99之间的一个索引.可能注意到(); so, the randomizer correctly picks an index between 0 and 99 inclusive. It might be noted that) NUM_LETTERS_IN_BAG 是随时间变化的全局变量,表示当前的上限.(is a global variable that changes with time and denotes the current upper bound.)

拖放(Drag-Drop)

游戏使用拖放事件在板上放置字母.当鼠标开始从机架中拖动一个字母时,该字母会触发鼠标下移事件.当字母被拖到板上的某个单元格上时,该板单元会触发拖动事件.当鼠标最终将字母放到板上单元格上时,该单元格将引发拖放事件.(The game uses drag-drop events for placing letters on the board. When a mouse starts dragging a letter from the rack, that letter fires a mouse-down event. When the letter is dragged over a cell on the board, that board cell fires drag-enter event. When the mouse finally drops the letter on the board cell, then that cell fires a drag-drop event.) 现在,让我们仔细考虑每次事件发生的细节.(Now let’s ponder into the details of what happens at each event.)

拖动开始(Drag Start)

假设正在从第一个玩家的架子的第一个单元中拖出一个字母.(Suppose a letter is being dragged from the first cell of the first player’s rack.)

接下来是第一个玩家的第一个机架的" MouseDown"事件.第一行将字母添加到变量"(Following is the ‘MouseDown’ event of the first cell of rack of the first player. The first line adds the letter in a variable ‘) Source ’.第二行使用该单元格上的字母开始拖放操作.(’. The second line starts a drag-drop operation with the letter that was on that cell.)

private void p0l0_MouseDown(object sender, MouseEventArgs e)
{
    string letter = AddSource(sender as Label);
    (sender as Label).DoDragDrop(letter, DragDropEffects.Copy);           
}

广义'(The generalized ‘) AddSource ’方法将标签与标签相交,以获取玩家的编号,鼠标所在的机架单元格以及该单元格上的字母.如果标签的名称为" p0l3",则玩家编号为0(第一位玩家),单元编号为3.(’ method intersects the label to get the player’s number, the cell of his/her rack where the mouse was down, and the letter that was on that cell. If the label’s name is ‘p0l3’, then the player’s number is 0 (first player), the cell number is 3.)

private string AddSource(Label sender)
{
    string letter = sender.Text;
    string name = sender.Name;

    int player = Convert.ToInt16(name.Substring(1, 1));
    int cellInRack = Convert.ToInt16(name.Substring(name.IndexOf("l") + 1));
    Source.Add(player, cellInRack, letter);
    return letter;
}

这是一个非常简单的字符串操作.这是一种常见的方法,所有28个鼠标按下事件都将调用此方法(4个播放器x 7个单元格).(This is a very easy string operation. This is a common method that is called by all the 28 mouse-down events (4 players x 7 cells each).) 总之,此方法跟踪鼠标拖动开始的源单元格详细信息.(In summary, this method keeps track of the source cell details where a mouse drag starts.)

拖动Enter(Drag Enter)

当玩家在板上的一个单元格上移动拖动鼠标时,就会发生拖动输入.这只是指示拖放操作完成后,将要从源中复制字母.(Drag enter occurs when the player moves the dragging mouse on a cell in the board. This simply instructs that, after the drag-drop operation completes, the letter is to be copied from the source.)

private void l0_0_DragEnter(object sender, DragEventArgs e)
{
    e.Effect = DragDropEffects.Copy;
}

电路板上的所有225个单元(15 x 15)必须有225个" DragEnter"事件.每个事件都需要放在同一行.不幸的是,没有机制可以立即分配它们以避免225个此类事件.(There needs to be 225 ‘DragEnter’ events for all the 225 cells (15 x 15) of the board. And each event needs to put the same line. Unfortunately, there is no mechanism to assign them at once to avoid 225 such events.)

掉落(Dropping)

当玩家最终释放板上板上某个单元的鼠标按钮时,就会发生拖放.(Drag drop occurs when the player finally releases the mouse button on a cell on the board.)

private void l0_0_DragDrop(object sender, DragEventArgs e)
{
    ProcessDragDrop(sender as Label, e);
}

该事件称为通用方法"(The event calls the generalized method ’) ProcessDragDrop ’.(’.)

private void ProcessDragDrop(Label boardCell, DragEventArgs e)
{
    string name = boardCell.Name;
    int x = Convert.ToInt16(name.Substring(1, name.IndexOf("_") - 1));
    int y = Convert.ToInt16(name.Substring(name.IndexOf("_") + 1));
    Control rackCell = Controls.Find($"p{Source.Player}l{Source.Cell}", true)[0];
    ……………………………………………………
    ……………………………………………………
}

此方法隔离标签(释放鼠标的位置)以获得轴.另外,它从鼠标拖动开始的地方获取源标签(rackCell).(This method segregates the label (where the mouse was released) to obtain the axis. Also, it obtains the source label (rackCell) from where the mouse drag started.) 例如,如果板单元格为" l12_14",则释放鼠标的单元格的轴为:x =12,y =14.(For example, if the board cell is ‘l12_14’, then axis of the cell where mouse was released is: x = 12, y = 14.) 接下来,以下行检查源单元格中是否有任何内容.从消息中可以看出,只有当玩家忘记拖动当前回合中已经拖动的相同字母时,才有可能.(Next, the following line checks if there was any content in the source cell. As seen from the message, this is only possible when a player forgetfully tries to drag the same letter that s/he dragged already in the current turn.)

if (rackCell.Text.ToCharArray().GetUpperBound(0) == -1)
{
    MessageBox.Show("Can't drag this tile. It was already dragged before; there is nothing in it.");
    return;
}

此后,下面的代码行检查放置该字母的单元格中是否已经包含另一个字母.(After that, the following line checks if the cell where the letter was dropped already contains another letter in it.)

else if (matrix[x, y] != '\0')
    MessageBox.Show("Occupied. Can't place here.");

然后,它检查所拖动的字母是否为空白图块.提醒一下,袋子里有两个空白砖.如果是空白图块,则允许玩家为图块选择一个字母((Then it checks if the dragged letter is the blank tile. Just to remind, there are two blank tiles in the bag. If it is a blank tile, then it allows the player to choose a letter for the tile () WildCardChooser 形成).该其他形式设置用户输入的所选通配符.(form). That other form sets the chosen wildcard as entered by the user.)

if (Source.Letter == ' ')
{
    WildCardChooser card = new WildCardChooser(this);
    card.Top = Cursor.Position.X;
    card.Left = Cursor.Position.Y;
    card.ShowDialog();

    if (WildCard == '\0')
    {
        MessageBox.Show("You didn’t choose any letter for the wild card. Choose a letter for the wild card or proceed with another letter in your rack.");
        return;
    }

    // This contains special contents (if any) of the board before dragging. E.g.: 2W, 3L etc.
    string specialCellContent = boardCell.Text;
    RackCellList.Push(new RackCell(Source.Player, Source.Cell, WildCard));
    boardCell.Text = WildCard.ToString();
    BoardCellList.Push(new BoardCell(x, y, specialCellContent, WildCard.ToString(), boardCell.BackColor));
    rackCell.Text = string.Empty;

    // After putting the wildcard letter, set the global variable to NULL to be used for the second wildcard.
    WildCard = '\0';
}

‘(‘) RackCellList ’是一个堆栈,其中包含当前回合(在机架中)拖动的单元格详细信息. ‘(’ is a stack that contains the dragged cell details (in the rack) in the current turn. ‘) BoardCellList ’是一个堆栈,其中包含鼠标放下字母的木板的单元格详细信息.堆栈用于三个目的.(’ is a stack that contains the cell details of the board where the mouse drops the letters. The stacks serve three purposes.)

• 如果用户错误地将字母放到错误的单元格中,则可以辅助" Ctrl + Z".(Assist with ‘Ctrl+Z’ if the user mistakenly drops the letter(s) in wrong cells.)
• 协助得分.(Assist in scoring.)
• 如果单词无效,则协助还原字母.(Assist in Reverting back the letters if the word is invalid.) 最后,如果是常规字母(从’A’到’Z’的任何字母)拖放,则只需将字母推入相应的堆栈即可.(Lastly, if it is a regular letter (any letter from ‘A’ to ‘Z’) drag-drop, then it simply pushes the letter to respective stacks.)

// This contains special contents (if any) of the board before dragging. E.g.: 2W, 3L etc.
string specialCellContent = boardCell.Text;
boardCell.Text = (string)e.Data.GetData(DataFormats.Text);
BoardCellList.Push(new BoardCell(x, y, specialCellContent, boardCell.Text, boardCell.BackColor));
matrix[x, y] = boardCell.Text.ToCharArray()[0];

RackCellList.Push(new RackCell(Source));
rackCell.Text = string.Empty;

总而言之,板上的225个单元(15 x 15)有225个拖动事件和225个拖放事件.(In summary, there are 225 drag-enter events and 225 drag-drop events for the 225 cells (15 x 15) of the board.)

换文(Exchange of Letters)

选择字母(Selecting Letters)

玩家可以在当前回合中交换部分或所有他/她的字母(假设包中至少有7个字母).在这种情况下,似乎无法用字母制作一个有效的单词,而玩家想尝试使用不同字母的运气.交换之后,当前回合被没收,下一位玩家继续前进.(A player can exchange some or all his/her letters in the current turn (given that there are at least 7 letters in the bag). This is the situation where it seems impossible to make a valid word with the letters and the player wants to try luck with different letters. After the exchange the current turn is forfeited, and the next player carries on.) 首先,通过选择字母,然后按"交换"按钮来促进交换.如果用户按CTRL键,然后单击一个字母,则该字母将添加到"字母"列表中.字母背景变成深红色,表示已被选中.如果已经选择了一个字母(深红色),并且播放器在按下CTRL键的同时单击了该字母,则将还原选择–从列表中删除该字母,并将图块颜色设置回正常的控制颜色((The exchange is facilitated first by selecting the letters, then pressing the ‘Exchange’ button. If the user presses CTRL-key, then clicks on a letter, that letter is added in a list of ‘Letters’. The letter background turns into Crimson to mean it was selected. If a letter is already selected (Crimson), and the player clicks on that letter while pressing CTRL-key, then that reverts the selection – the letter is removed from the list and the tile colour is set back to normal control colour () SystemColors.Control ).().)

List<Letters> ExchangingLetters = new List<Letters>();
private readonly Color EXCHANGE_LETTER_CELL_COLOR = Color.Crimson;

private void AddLettersToExchangeTotheList(Label label)
{
    // If the label's back colour is already crimson, then it removes the letter from the list.
    if (label.BackColor == EXCHANGE_LETTER_CELL_COLOR)
    {
        // Change the colour back to system control colour.
        label.BackColor = SystemColors.Control;

        // Remove the letter from the exchanging list.
        ExchangingLetters.Remove(ExchangingLetters.Find(x => x.Letter == label.Text.ToCharArray()[0]));
    }
    else
    {
        int pos = Convert.ToInt16(label.Name.Substring(3));
        ExchangingLetters.Add(new Letters(label.Text.ToCharArray()[0], pos));
        label.BackColor = EXCHANGE_LETTER_CELL_COLOR;
    }
}

换信(Exchanging Letters)

当玩家按下"交换"时,列表中的字母"(When the player presses ‘Exchange’, the letters in the list ‘) ExchangingLetters “放回购物袋,输入新字母,然后将深红色替换为常规对照色.绘制随机选择的新随机字母. (如果退回相同的字母,不要责怪游戏.我记得比恩先生出过一集,他试图退回食物,但又把同样的东西带回了桌上:))(’ are returned to the bag, new letters are brought in and the crimson colour is replaced with regular control colour. New random letters are drawn which are randomly selected. (Don’t blame the game if the same letters are returned. I remember an episode from Mr. Bean where he tried to return a food item but got the same item brought back to his table :)).) 交换之前,需要进行细微的检查,以确定用户在当前回合中是否在板上放置了任何字母.在船上放信件和选择交换是互斥的–它们不能一起发生.在这种情况下,它会显示一条消息并且不会交换.如果玩家真的选择交换,则首先应将字母放回机架(CTRL + Z).玩家是否在棋盘上放置了字母,并通过两个保持移动的列表来检查.从逻辑上检查其中一个都可以,因为两者的条目数相同.(Before an exchange, there is a minor check if the user placed any letter on the board in the current turn. Placing letters on board and opting for exchange are mutually exclusive – they cannot happen together. In that case it displays a message and doesn’t exchange. If the player really opts for exchange, then the letters first should be taken back to rack (CTRL+Z). Whether the player placed letters on the board is checked by the two lists maintained for the movements. Logically checking either will do, as both will have the same numbers of entries.)

if (RackCellList.Count > 0 || BoardCellList.Count > 0)
{
    MessageBox.Show("You already dragged letters on the board. Can't exchange now. First return the letters (CTRL+Z).");
    return;
}

如果此检查通过,则将字母飞回袋子.(If this check passes, then the letter(s) are flown back to the bag.)

foreach (Letters l in ExchangingLetters)
{
    ctl = Controls.Find($"p{CurrentPlayer}l{l.Pos}", true)[0];      // E.g.: p2l0.

    // Obtain absolute location of the rack's cell from the top left of the window.
    cellAbsLoc = ctl.FindForm().PointToClient(ctl.Parent.PointToScreen(ctl.Location));

    lblFlyingLetter.Text = ctl.ToString();

    // Change the rack cell back colour to normal.
    ctl.BackColor = SystemColors.Control;
    ctl.Text = string.Empty;
    FlyLetter(cellAbsLoc, FlyingLetterInitialPosOnBag);

    LetterBag[l.Pos] = l.Letter;
    lblLettersRemaining.Text = $"Letters remaining: {++NUM_LETTERS_IN_BAG}";
    Application.DoEvents();
}

将字母放回袋子后,新字母将被带到袋子的空单元中.(After the letters are returned to the bag, new letters are brought in the empty cells from the bag.)

foreach (Letters l in ExchangingLetters)
    LoadSingleLetter(CurrentPlayer, l.Pos);

最后,清除了交换信件的列表(“交换信件”).(Finally, the list of exchanging letters (‘ExchangingLetters’) is cleared off.)

ExchangingLetters.Clear(); // Clear the exchanging letters list.

动画效果(Animation Effects)

在三种可能的情况下,有两种主要的动画效果.一种是摇晃袋子,另一种是将信件飞过袋子,架子和木板.(There are two main animation effects in three possible scenarios. One is bag-shaking, the other one is flying the letters across the bags, racks and board.) 只有一种可能的情况是摇晃袋子.每当要从包装袋中取出一组新字母时,包装袋都会摇动,表示要从包装袋中抽取字母.(There is only one possible scenario of bag-shaking. Whenever a new set of letters are to be drawn from the bag, then the bag shakes to mean letter(s) are going to be drawn from the bag.) 信件飞行的三种可能情况:(The three possible scenarios for the letter flights:)

• 从袋子飞到架子.(Fly from bag to rack.)
• 从架子飞到袋子.(Fly from rack to bag.)
• 从木板飞到架子上.(Fly from board to rack.)

摇袋(Bag-shaking)

这很简单.计时器用于每50毫秒滴答作响,上下移动袋子.在滴答声中,它迫使线程休眠10毫秒((This is very simple. A timer is used to tick every 50 milliseconds, moving the bag up and down. During the ticks it forces the thread to sleep 10 milliseconds () THREAD_SLEEP=10 )以使运动可见.如果不诱发这种睡眠,那么它将迅速摇动闪电;因此玩家将无法感知晃动的效果.() to make the movement visible. If this sleep is not induced, then it would shake lightning fast; so the player(s) won’t be able to perceive the shaking effect.)

pbLetterBag.Top += SHAKE_PIXELS;
SHAKE_PIXELS = -SHAKE_PIXELS;
Thread.Sleep(THREAD_SLEEP);
Application.DoEvents();

‘(‘) pbLetterBag ’是包含袋子的图像控件.第一次滴答时,它会向下移动20像素((’ is the image control containing the bag. On first tick it moves down 20 pixels () SHAKE_PIXELS=20 ).然后 ‘(). Then ‘) SHAKE_PIXELS ’否定自己;现在变成(-20).在下一个刻度中,它向上移动((’ negates itself; it becomes (-20) now. In the next tick it moves up () pbLetterBag.Top += SHAKE_PIXELS ).在下一个刻度中变为(-(-20)=+20)((). In the next tick it becomes (-(-20) = +20) () SHAKE_PIXELS = -SHAKE_PIXELS ),因此它向下移动.而且这种情况持续了一段时间.(), so it moves down. And things keep going like this for a while.) 袋子摇晃一定次数后((After the bag shakes a certain number of times () MAX_SHAKE_COUNT=13 ),则计时器停止计时,行李袋处于静止状态.(), then the timer stops, and the bag is at rest.)

在书包,木板和架子之间飞信(Fly Letters between the Bag, Board and Racks)

字母飞行是一个简单的动画,可以在字母袋,机架式单元格和板式单元格之间悬挂标签.它为字母移动创建了简单的视觉效果.隐喻地可以解释为源机场,目的机场,飞机和乘客.标签控件用作飞机.需要飞行的字母是飞机的乘客.源是起飞的位置,目标是降落的位置.(The flight of letters is a simple animation that flies a label in between the letter bag, rack cells, and board cells. It creates a simple visual effect for the letter movement. Metaphorically this can be explained as a source airport, a destination airport, an aeroplane and a passenger. A label control is used as the aeroplane. The letter that needs to fly is the passenger of the plane. Source is the location from where it takes off, destination is where it lands on.) 方法 ‘(The method ‘) FlyLetter ’是飞行逻辑的控制塔.它从调用方接收两个参数-源和目标.(’ is the control tower of the flying logic. It receives two parameters from the caller – the source and the destination.) 该方法首先计算从目标到源的轴差.它在配置文件中具有预定义的帧数(可配置).然后,通过将差除以帧计数(例如25帧),确定在每个方向上有多少像素飞行.四舍五入(The method first calculates the axis difference from destination to source. It has a pre-defined frame count in the configuration file (configurable). Then it determines how many pixels to fly at each direction by dividing the difference by the frame count (e.g. 25 frames). It rounds up to 4)日(th)十进制(例如:25.2153).(decimal (e.g.: 25.2153).)

// Determine axis distance (destination - source).
diff = new Point(dest.X - source.X, dest.Y - source.Y);

// Determine stepping needed by the letter - how many pixels to fly through x and y axes.
SteppingX = Math.Round(diff.X / MAX_ANIMATION_FRAMES, 4);
SteppingY = Math.Round(diff.Y / MAX_ANIMATION_FRAMES, 4);

双精度舍入值有什么要求？如果仅取整数舍入值怎么办？让我们通过示例进行说明.(What is the need for the double-precision round value? What if just integer round value was taken? Let’s clarify that through an example.) 假设飞行标签(飞机)最初位于(750,50).假设步进X =-10.48,步进y =1.52.(Suppose the flying label (the aeroplane) is initially at (750, 50). Let’s say the stepping X = -10.48, stepping y = 1.52.) 第一帧的标签为:(750-10.48,50 + 1.52)=(739.52,51.52).(The first frame takes the label to: (750 - 10.48, 50 + 1.52) = (739.52, 51.52).) 由于像素需要为整数,因此将其舍入为(740,52).(Because pixels need to be integers, so this is rounded to (740,52).) 但是,我们在全局变量中记录了最后一个双精度位置.我们使用最后记录的双精度位置来计算下一步.(However, we recorded the last double-precision location in a global variable. We use that last-recorded double-precision location to calculate the next move.) 因此,下一个位置是(739.52 – 10.48,51.52 + 1.52)=(729.12,53.04).(Hence, the next location is (739.52 – 10.48, 51.52 + 1.52) = (729.12, 53.04).) 为此,舍入的像素值为(729,53).(The rounded pixel values for this is (729, 53).) 现在让我们看看如果使用整数步进(四舍五入)会发生什么情况.(Now let’s see what happens if integer steppings (rounded) are used.) 第一帧是(740,12).(The first frame is (740, 12).) 舍入后的下一帧为(740 – 10.48,52 + 1.52)=(729.52,53.52)=(730,54).(The next frame after rounding is (740 – 10.48, 52 + 1.52) = (729.52, 53.52) = (730, 54).) 参见,这与(729,53)不同,后者在计算上是正确的,并且位置更加精确.如果使用后者,则图块将以固定速率移动,并将标签飞出目的地,然后将其放置在目的地.会出现一些动画混动.隐喻地,飞机将飞越跑道,并且需要再次尝试正确着陆.(See, this is not the same as (729, 53), which is calculatedly correct and more precise location. If the latter is used then the tile would move at flat rate and would fly the label outside the destination, then will drop it there. A little jerk of animation would be visible. Metaphorically, the airplane would fly beyond runway and will need a second attempt to land correctly.) 前循环有助于飞行-循环播放最大帧数((A For-Loop facilitates the fly – it loops for the maximum frame count () MAX_ANIMATION_FRAMES=25 ),它会在每个步骤中计算出瓷砖的下一个位置,将其飞到那里并等待片刻((), at each step it calculates the next location of the tile, flies it there and waits a few moments () THREAD_SLEEP=10 ),以便玩家可以感知飞行情况.() so the player can perceive the flight.)

for (int i = 0; i < MAX_ANIMATION_FRAMES; i++)
{
    lastXOfFlyingLabel += SteppingX;
    lastYOfFlyingLabel += SteppingY;

    // Convert the double-precision to int, as pixel needs to be int.
    lblFlyingLetter.Left = (int)lastXOfFlyingLabel;

    // Convert the double-precision to int, as pixel needs to be int.
    lblFlyingLetter.Top = (int)lastYOfFlyingLabel;

    // Unless forced, the effect will not be visible.
    Application.DoEvents();

    // Allow delay else this will be too fast to see.
    Thread.Sleep(THREAD_SLEEP);
}

袋收缩,即阵列收缩(Bag Shrinking, i.e., Array Shrinking)

转弯完成后(成功或失败),阵列需要收缩.这是面试官普遍提出的面试问题.(After a turn is complete (either successful or failure), the array needs to shrink. This is a popular interview question asked by interviewers.) 让我们想一想,如果在搬迁之后保持原样,将会发生什么.该数组最终将包含越来越多的NULL(\ 0)字符(请记住,每次从书包中提取字母时,对应的条目将被无效以表示该字母已被使用).这使得随机化器最终很难找到字母.慢慢成为瓶颈.(Let’s think of what would happen if we leave it as such after the moves. The array would eventually contain more and more NULL (\0) characters (remember, each time letters are drawn from the bag, the corresponding entry is nullified to mean the letter is taken). This makes the randomizer difficult to find a letter eventually; it becomes a bottleneck slowly.)

对于一百个单元阵列,这可能无法识别,但是如果我们考虑阵列中的数百万个单元,那么线下将成为处理器查找非空白单元的瓶颈.(For a hundred cell-array this might not be recognizable, but if we consider millions of cells in the array, then down the line it becomes a bottleneck for the processor to find a non-blank cell.) 这里使用的逻辑是对阵列的一次扫描.扫描从两种方式进行-从正面和背面,因此为O(n).逻辑如下:(The logic used here is a single sweep of the array; the sweep proceeds from both ways – from the front as well as the back, hence O(n). The logic is as following:)

• 从数组的开头开始.我们将索引指示器称为” pos".(Start from the beginning of the array. Let’s call the index indicator ‘pos’.)

• 一旦找到NULL单元格(该单元格的字母在当前回合中绘制),然后标记该位置.我们将其命名为" pos".(As soon as a NULL cell is found (the letter of that cell was drawn in the current turn), then mark that position. Let’s name it ‘pos’.)

  • 现在从末尾开始遍历.(Now start traversing from the end.)
  • 一旦找到非NULL单元格,则标记该位置.我们将其命名为" lastPickPos".(As soon as a non-NULL cell is found, then mark that position. Let’s name it ‘lastPickPos’.)
  • 将" lastPickPos"的字母复制到" pos".(Copy the letter of the ‘lastPickPos’ to ‘pos’.)
  • 取消" lastPickPos"的字母.(Nullify the letter of ‘lastPickPos’.)

• 循环播放,直到" pos"越过" lastPickPos".此时,所有NULL值都会被破坏(移至末尾).(Loop until the ‘pos’  crosses ‘lastPickPos’. At this point all the NULL values are compromised (moved to the end).)

• 现在修剪尾随的NULL.这会缩小数组.(Now trim the trailing NULLs. This shrinks the array.)

private void ShrinkLetterBag()
{
    int len = LetterBag.GetUpperBound(0); // Initial length of the bag.
    int lastPickPos = len; // Last index is the length of the array.

    // Start traversing from the beginning.
    for (int pos = 0; pos < lastPickPos; pos++)      // Start traversing from the beginning.
    {
        if (LetterBag[pos] == '\0')                  // If a NULL is detected
        {
            while (lastPickPos > pos && LetterBag[lastPickPos] == '\0')
                lastPickPos--;
            LetterBag[pos] = LetterBag[lastPickPos]; // Copy that last character to the beginning NULL index.
            LetterBag[lastPickPos] = '\0';           // Nullify the last pick index.
        }
    }
    NUM_LETTERS_IN_BAG = lastPickPos;
    Array.Resize(ref LetterBag, NUM_LETTERS_IN_BAG);
}

修剪((The trimming () Array.Resize )实际上是不需要的,因为随机化器仅处理上限,该上限指向数组中最后一个非空字符的下一个点.() is actually not needed as the randomizer deals with upper bound only which points next to the last non-null character in the array.)

撤消动作(Undoing Moves)

玩家可以在回合中撤消字母拖曳.要撤消操作,只需按需要多次按CTRL + Z.通过以下逻辑可以简化此过程.(Players can undo the letter drags during a turn. To undo they need to simply press CTRL+Z as many times as needed. This is facilitated through the following logic.) 每次从单元格中拖动字母时,都会从该单元格触发"鼠标向下"事件.在这种情况下,该单元格的详细信息(玩家,该单元格在机架上的位置以及该单元格中的字母)会添加到"(Each time a letter is being dragged from a cell, a ‘mouse down’ event is triggered from that cell. In the event, the details of the cell (player, position of the cell on the rack and the letter that was in the cell) are added to a variable of type ‘) RackCell ’.(’.)

private string AddSource(Label sender)
{
    string letter = sender.Text;
    string name = sender.Name;

    int player = Convert.ToInt16(name.Substring(1, 1));
    int cellInRack = Convert.ToInt16(name.Substring(name.IndexOf("l") + 1));
    Source.Add(player, cellInRack, letter);
    return letter;
}

将字母放到板上的某个单元上之后,该单元会触发"拖放"事件.此事件将那些详细信息添加到列表(堆栈).(After the letter is dropped on a cell on the board, that cell triggers a ‘drag drop’ event. This event adds those details to a list (stack).)

Stack<RackCell> RackCellList = new Stack<RackCell>();
……………………………
……………………………
RackCellList.Push(new RackCell(Source));

为什么为此选择堆栈而不是其他数据结构？你猜对了. CTRL + Z需要以与拖放相反的方式工作.当按下CTRL + Z时,最后一个操作将首先被撤消.(Why stack is chosen over other data structures for this? You guessed right. CTRL+Z needs to work in the reverse manner of the drag-drops. The last action is to be reversed first when CTRL+Z is pressed.) 通过覆盖表单的默认按键处理器"(The CTRL+Z is facilitated by overriding the form’s default key-stroke processor ‘) ProcessCmdKey ’.(’.)

protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
{ …………………………… …………………………… }

CTRL + Z由CTRL键与" Z"的按位"或"表示.(CTRL+Z is comprehended by bitwise OR of CTRL-key with ‘Z’.)

if (keyData == (Keys.Control | Keys.Z))
{ …………………………… …………………………… }

如果是CTRL + Z,则只需执行以下操作:(If it is a CTRL+Z, then simply perform the following actions:)

• 弹出机架单元的详细信息.(Pop the details of the rack cell.)
• 弹出板单元的详细信息.(Pop the details of the board cell.)
• 将机架单元的文本设置为拖动前的文本.(Set the rack-cell’s text to what it was before dragging.)
• 将板单元的文本设置为放置前的文本.(Set the board-cell’s text to what it was before dropping.)
• 将矩阵中的相应单元格设置为NULL.(Set the corresponding cell in the matrix to NULL.) 从堆栈中删除条目是由系统自动完成的(Removing the entry from the stacks is done automatically by the) pop() 操作.(operation.)

一个词的有效性(Validity of a Word)

为了成为一个有效的单词,它需要通过以下内容.(To be a valid word, it needs to pass the following.)

• 它应该具有有效的方向.(It should have a valid orientation.)
• 它应该具有有效的邻接关系.(It should have a valid adjacency.)
• 如果它是第一个单词,那么它应该穿过中央星图块.(If it is the first word, then it should cross through the central star tile.)
• 在其他时间,该单词应穿过或触摸板上的现有字母.(For other times, the word should cross through or touch existing letters on the board.)

1)有效方向(1) Valid Orientation)

定向的有效性由"(Validity of orientation is confirmed by the ‘) ValidOrientation ' 方法.(’ method.) 单词可以具有水平或垂直方向.首先,它检查它是否为一滴水-玩家只滴了一个字母.在这种情况下,它尝试通过检查板上的现有单词来推断预期的方向.这很简单-只需检查当前字母的顶部或底部是否有字母-在这种情况下,推断的方向是垂直的.另一方面,如果在字母的左边或右边有一个字母,则为水平方向.(A word can have either horizontal or vertical orientation. First it checks if it is a single drop – the player dropped a single letter only. In this case it tries to infer the intended orientation by checking with the existing words on the board. This is simple – just check if there is a letter to the top or to the bottom of the current letter – in that case, the inferred direction is vertical. On the other hand, if there is a letter to the left or to the right of the letter, then this is a horizontal orientation.)

int x = boardCells[0].X;
int y = boardCells[0].Y;
int yBelow = y + 1;
int yAbove = y - 1;
int xLeft = x - 1;
int xRight = x + 1;

// If there is a letter above or below the singly-placed letter, then the inferred direction is vertical.
if ((yAbove >= 0 && matrix[x, yAbove] != '\0') || (yBelow < GRID_SIZE && matrix[x, yBelow] != '\0'))
    CurrentWordDirection = WordDirectionEnum.Vertical;
……………………………
……………………………

例如,如果在板上拖动单个字母" A",则会在其上方找到一个字母" C",因此可以推断出预期的垂直方向.(For example, if a single letter ‘A’ is dragged on the board, it finds a letter ‘C’ above it, hence it inferred the intended orientation as vertical.)

如果玩家在板上拖动了多个字母,则首先通过检查前两个字母来确定方向.(If the player dragged multiple letters on the board, then it first determines the orientation by checking the first two letters.)

// If this is a vertical drop to the previous drop, then mark the direction as vertical.
if (boardCells[0].X == boardCells[1].X && Math.Abs(boardCells[0].Y - boardCells[1].Y) >= 1)
    CurrentWordDirection = WordDirectionEnum.Vertical;

// If this is a horizontal drop to the previous drop, then mark the direction as horizontal.
else if (boardCells[0].Y == boardCells[1].Y && Math.Abs(boardCells[0].X - boardCells[1].X) >= 1)
    CurrentWordDirection = WordDirectionEnum.Horizontal;

然后,它遍历其余字母,并检查其余字母是否遵循相同的方向.如果所有方向都相同,则返回true确认.否则,它返回false.(Then it loops through the rest of the letters and checks if the rest of the letters follow the same orientation or not. If all follow the same orientation, then it confirms that by returning true. Otherwise, it returns false.)

WordDirectionEnum dir = WordDirectionEnum.None;
for (int i = 1; i < boardCells.Count - 1; i++)
{
    // Check orientation of each subsequent drops.
    if (boardCells[i].X == boardCells[i + 1].X && Math.Abs(boardCells[i].Y - boardCells[i + 1].Y) >= 1)
        dir = WordDirectionEnum.Vertical;
    else if (boardCells[i].Y == boardCells[i + 1].Y && Math.Abs(boardCells[i].X - boardCells[i + 1].X) >= 1)
        dir = WordDirectionEnum.Horizontal;

    // If this orientation is not the same as the first, then this must be an abnormal orientation.
    if (dir != CurrentWordDirection)
    {
        MessageBox.Show("Abnormal orientation detected. Letters must be placed horizontally or vertically. Cannot proceed!"
            , Properties.Resources.APP_TITLE, MessageBoxButtons.OK, MessageBoxIcon.Information);
        CurrentWordDirection = WordDirectionEnum.None;
        return false;
    }
}

例如,如果玩家在板上放置了" A"," T"," E"和" R",那么它首先通过检查前两个字母" A"和" T"来推断方向为垂直.然后,循环继续遍历其余字母" E"和" R",并期望它们保持相同的方向.(For example, if the player placed ‘A’, ‘T’, ‘E’ and ‘R’ on the board, then it first infers the direction as vertical by checking the first two letters ‘A’ and ‘T’. Then the loop continues through the rest of the letters ‘E’ and ‘R’ and expects that they maintain the same orientation.)

如果不是,则这是无效的方向.例如:(If not, then this is an invalid orientation. For example:)

理想情况下,这不会发生,因为玩家不太可能随机玩.但是,无论任何事情,都应该小心谨慎,尽管这可能很奇怪.(Ideally this would not happen as the player is not likely to play random. But care should be taken for everything, however odd that might be.)

2)有效邻接:(2) Valid Adjacency:)

要创建有效的单词,字母必须彼此相邻或与板上的现有字母相邻.(To make a valid word, the letters need to be adjacent either by themselves or with existing letters on the board.) 让我们尝试解释一个水平定向单词的邻接检查.首先,它将字母从左到右排序.(Let’s try to explain the adjacency check for a horizontally directed word. First it sorts the letters from left to right.)

// Clone the list sorted from top to bottom.
List<BoardCell> boardCells = boardCellList.Select(a => a).OrderBy(b => b.X).ToList();

然后它从左到右循环通过它们.如果两个连续字母之间存在一个以上的单元间隙,则它将检查那些间隙单元中是否存在任何现有字母.(Then it loops through them from left to right. If there is more than one cell gap between two consecutive letters, then it checks if there is any existing letter in those gap-cells.)

for (int i = 0; i < boardCells.Count - 1; i++)
{
    // If the distance between the consecutive letters are more than a cell, that would mean
    // the cells in between must contain existing letters. Else this would be deemed invalid placement.
    if (boardCells[i + 1].X - boardCells[i].X > 1)
        // Start traversing from the next cell of the left cell, walk towards the left cell of the right cell.
        for (int j = boardCells[i].X + 1; j < boardCells[i + 1].X; j++)
            // If that cell is empty, means this is an invalid placement.
            if (matrix[j, boardCells[i].Y] == '\0')
            {
                MessageBox.Show("Letters don't have valid horizontal adjacency. Cannot proceed!"
                    , Properties.Resources.APP_TITLE, MessageBoxButtons.OK, MessageBoxIcon.Information);
                return false;
            }
}

例如,假设棋盘上已有" ACT"," STAY"," SOOTH"," HOE"或" PAT"这两个词,而玩家尝试通过它们来制作SCATTERS.玩家将S,A,T,S放在棋盘上.在水平方向上,S和A之间有一个以上的单元间隙.因此,两者之间必须存在现有字母(即C).然后,T和S之间有三个单元格间隙,它们之间必须有字母(它们分别是T,E,R).因此,这是有效的邻接关系.(For example, let’s say there are existing words ACT, STAY, SOOTH, HOE, OR, PAT on the board and the player tries to make SCATTERS through them. The player placed S, A, T, S on the board. Horizontally S and A has more than one cell gap in between. Hence there must be existing letters in between (which is C). Then there are three cells gap between T and S, which must have letters in between (which are T, E, R). Hence this is a valid adjacency.)

无效的邻接可能是以下情况:(An invalid adjacency might be the following:)

3)穿过中央磁贴获得第一个单词(3) Crossing Through Central Tile for the First Word)

这很简单.星块位置是(7,7).只需遍历所有放置的字母,然后查看其中是否有位置(7,7)即可.逻辑适用于方法’(This is very simple. The star-tile location is (7, 7). It is just a matter of looping through all the placed letters and see if any of then has the location (7, 7). The logic is applied in the method ‘) FirstWordThroughCentralStarTile ’.(’.)

foreach (BoardCell c in boardCellList)  // Loop through all the cells.
    // If any of them contains (7, 7) - the central tile, then return true.
    if (c.X == 7 && c.Y == 7)
        return true;

MessageBox.Show("The first word should pass through the central star tile. Use CTRL+Z to return the letters, then place through the star."
    , Properties.Resources.APP_TITLE, MessageBoxButtons.OK, MessageBoxIcon.Information);

// If none of them contains (7, 7), then return false.
return false;

4)交叉(或触摸)现有单词(4) Crossing (or touching) existing words)

可以通过两种方式检查交叉.(Check for crossing can be done in two ways.)

• 查看黑板上单词周围的图块,看看其中是否有灰色((Look at the surrounding tiles of the word on the board and see if any of them is grey coloured () SystemColors.ControlDarkDark ).如果周围的任何一个单元格是灰色的,则意味着当前单词越过(或触摸)了现有单词.如果当前单词的任何字母周围的瓷砖都不是灰色,则表示玩家将单词隔离放置,因此将被视为无效放置(单词应相互交叉).(). If any of the surrounding cells is grey, then that would mean the current word crossed through (or touched) an existing word. If none of the surrounding tiles of any letters of the current word is grey, that would mean the player placed the word isolated, hence would be deemed invalid placement (words should cross each other).)
• 查看矩阵的周围单元格,看看它们是否为非NULL.非NULL表示板上有一个现有的有效字,因此当前的字位置是有效的(因为它接触或穿过现有字).否则,这是无效的.(Look at the surrounding cells of the matrix and see if any of them is non-NULL. A non-NULL would mean there is an existing valid word on the board, hence the current word placement is valid (as it touches or crosses through an existing word). Else, this is invalid.) 任何一种都可以实现.在该项目中,选择了第二个选项.第一个检查UI元素的颜色,因此将需要更多时间.同样,第一种方法是捷径,而第二种方法在通过2D字符数组进行编码方面更具启发性.此外,它更快,因为它使用字符矩阵,而不使用任何UI元素.(Either one can be implemented. In this project the second option is chosen. The first one checks UI element colour, hence would require more time. Also, the first approach is a shortcut, while the second one is more thought-provoking in terms of coding through a 2D character array. Further, it is faster as it uses the character matrix, not any UI element.) 检查是通过"(The check is done in the method ‘) CurrentWordCrossedThroughExistingWord ’.如果单词越过或触摸了板上的现有单词,则该方法返回true.它接受四个参数,玩家在板上拖动的字母列表,角色矩阵,当前玩家和当前回合.需要最后两个参数来记录移动.它们在检查穿越的逻辑中没有任何作用.(’. The method returns true if the word crossed through or touched an existing word on the board. It accepts four parameters, the list of letters that the player dragged on the board, the character matrix, the current player and the current turn. The last two parameters are needed to record the move; they don’t play any role in the logic for checking cross through.) 可以有两个方向-水平和垂直.在这一部分中,仅说明了水平方向.通过这个可以理解垂直的.(There can be two orientations  – horizontal, and vertical. In this part, only the horizontal orientation is explained; the vertical one can be understood through this.) 首先,字母从左到右排序.(First, the letters are sorted from left to right.)

// Take a clone of the stack and order from left to right.
letters = letters.Select(a => a).OrderBy(a => a.X).ToList();

然后,它检查第一个字母的左侧-如果那里有任何字母,则表示该单词越过(或触摸)了板上的现有单词.还需要确保此检查不会超出范围(x> =0),因为这会产生运行时错误.(Then It checks the left of the first letter – if there is any letter there, then that would mean the word crossed through (or touched) an existing word on the board. It also needs to make sure that this check doesn’t fall outside the bounds (x >= 0), as that would generate runtime error.)

x = letters.First().X - 1;              // Check left of the first letter.
y = letters.First().Y;
if (x >= 0)                             // If not falling out of grid.
    if (matrix[x, y] != '\0')           // If there is a non-NULL character in the cell.
        return true;                    // Then return true.

例如,如果CATER已经在棋盘上,并且玩家通过放置A和P来制作CAP,那么它会检查" A"左侧是否有一个字母(这是正确的).(For example, if CATER is already on the board, and the player makes CAP by placing A and P, then it checks if there is a letter to the left of ‘A’ (which is true).)

如果第一个字母的左边没有字母,请检查最后一个字母的右边是否有字母.这还需要确保它不超出边界(x <GRID_SIZE).(If there is no letter to the left of the first letter, then check if there is any letter to the right of the last letter. This also needs to make sure that it doesn’t fall outside the boundary (x < GRID_SIZE).)

x = letters.Last().X + 1;               // Check right of the last letter.
y = letters.Last().Y;
if (x < GRID_SIZE)                      // If not falling out of grid.
    if (matrix[x, y] != '\0')           // If there is a non-NULL character in the cell.
        return true;                    // Then return true.

例如,如果POT已经在棋盘上,并且玩家通过放置C和A来获得CAP,那么它会检查" A"右边是否有一个字母(这是正确的).(For example, if POT is already on the board, and the player makes CAP by placing C and A, then it checks if there is a letter to the right of ‘A’ (which is true).)

如果以上两个条件均不能确定真相,则下一步是遍历所有字母,并检查上方和下方的单元格中是否有字母-显然,如果找到字母,则表示当前单词穿过(或触碰到)板上的现有单词.同样,这需要确保支票不会超出范围((If none of the above two could determine the truth, then the next step is to loop through all the letters and check if any of the above and below cells has a letter – obviously, if a letter is found, that would mean the current word crossed through (or touched) an existing word on the board. Again, this needs to make sure that the check doesn’t fall outside the bounds () y >= 0, y < GRID_SIZE ).().)

foreach (BoardCell c in letters)
{
    x = c.X;
    y = c.Y - 1;                        // Check top.
    if (y >= 0)                         // If not falling out of grid.
        if (matrix[x, y] != '\0')       // If there is a non-NULL character in the cell.
            return true;                // Then return true.

    x = c.X;
    y = c.Y + 1;                        // Check bottom.
    if (y < GRID_SIZE)                  // If not falling out of grid.
        if (matrix[x, y] != '\0')       // If there is a non-NULL character in the cell.
            return true;                // Then return true.
}

例如,如果棋盘上有现成的单词(PAN,NO和ONE),而玩家想铸造单词CANOPY,那么我们手上有C,A,P,Y.我们检查每个字母的顶部和底部单元格,以查看是否有任何字母.由于这是错误的(C,A,P,Y中没有一个字母在上方或下方),因此仍无法确定它是否碰到任何现有单词.记住,我们使用的BoardCellList仅包含C,A,P和Y. BoardCellList没有介于N和O之间的线索,这就是我们接下来要发现的.(For example, If there are existing words on the board (PAN, NO and ONE) and the player wants to coin the word CANOPY, then we have C, A, P, Y at our hand. We check each of the letters’ top and bottom cells to see if there is any letter there. Since this is false (none of C, A, P, Y has a letter above or beneath), so it is still not decided if it touched any existing word. Remember, we our using our BoardCellList which have C, A, P and Y only. The BoardCellList doesn’t have a clue of N and O which are in between and that is what we are going to discover next.)

如果仍然无法确定关于穿越的真相,那么最后要检查的是字母之间是否存在字母.从最左边的单元格的右边的单元格开始,向最右边的单元格的左边的单元格走,看看之间是否存在所有字母.需要注意的是,我们只需要检查不在当前列表中的字母.(If the truth about crossing still could not be determined, then the last thing to check is if there are existing letters in between the letters. Start with the right cell of the leftmost cell, walk towards the left cell of the rightmost cell, and see if there are existing letters in all the cells in between. The caveat here is, we have to check only the letters that are not in the current list.)

for (x = letters.First().X + 1, y = letters.First().Y; x < letters.Last().X; x++)
    // If this is not already in the current player's cell list.
    if (letters.FirstOrDefault(a => a.X == x && a.Y == y) == null)
        if (matrix[x, y] != '\0')       // If there is a non-NULL character in the cell.
            return true;                // Then return true.

例如,让我们来看上一个示例.我们开始从A步行到P(请记住,玩家放置C,A,P,Y),然后发现中间有任何字母.首先找到A,但是由于A在当前的BoardCellList中,因此这不是现有字母.我们继续并找到了N.由于我们找到了N(即非NULL字符),所以我们可以直接宣称我们已经找到了真相–单词穿过(或触摸)了一个现有字母.我们不需要进一步进行操作,因为任何其他信件都应该事先经过验证.(For example, let’s examine with the previous example. We start walking from A until P (remember, player placed C, A, P, Y) and see there is any letter in between. First found A, but since A is in the current BoardCellList, so this is not an existing letter. We proceed on and found N. Since we found N (i.e., a non-NULL character), we can straight away proclaim that we have found the truth – the word crossed through (or touched) an existing letter. We don’t need to proceed further as any other letter should have been already verified beforehand.)

如果仍然无法确定真相,而我们到了这一点,那么这意味着原意的单词没有穿过或碰到黑板上的任何现有字母;因此它记录了情况并返回false.(If the truth still could not be determined and we reached this point, then this would mean the intended word didn’t cross through or touched any existing letter on the board; hence it records the situation and returns false.)

MessageBox.Show("The word didn't cross through, or touched another word. Not a valid placement."
    , Properties.Resources.APP_TITLE, MessageBoxButtons.OK, MessageBoxIcon.Information);
Players[currentPlayer].ScoreDetails.Add(new TurnsWithScores(currentTurn, $"Disjoint word coined.", null));
return false;

垂直字的检查与此类似,因此不作解释.(The check for vertical word is similar to this, so that is not explained.)

计分(Scoring)

计分逻辑有点复杂,用于此目的的数据结构也是如此.主要有两个步骤–加载字典和验证创建的单词.(Scoring logic is a bit complex, so are the data structures used for the purpose. There are two main steps – loading the dictionary and validating the created word.)

正在加载字典(Loading Dictionary)

为了评分,显然需要词典.来自的开源JSON字典(For scoring, obviously a dictionary is needed. An open source JSON dictionary from) 这里(here) 用于此目的(即172,819个单词).(is used for the purpose (which as 172,819 words).)

[
    "aa",
    "aah",
    "aahed",
    "aahing",
    "aahs",
    "aal",
    "aalii",
    "aaliis",
    "aals",
    ……………………………….
    ……………………………….
    "zymurgy",
    "zyzzyva",
    "zyzzyvas"
]

可以注意到,这是一个字符串数组.游戏开始时,字典中的单词会加载到JToken列表的"单词"中.首先,我们在字符串变量" jsonWords"中获取整个字典,然后在名为" json"的JArray变量中反序列化.最后,将JArray转换为JToken列表.(It may be noted that this is an array of strings. At the very beginning of the game the words from the dictionary are loaded in ‘Words’ which is a JToken list. First we obtain the entire dictionary in a string variable ‘jsonWords’, then that is deserialized in a JArray variable named ‘json’. Finally, the JArray is converted to a JToken list.)

private static List<JToken> Words;
string jsonWords;
using (StreamReader reader = new StreamReader(WORD_FILE_NAME))
    jsonWords = reader.ReadToEnd();
JArray json = (JArray)JsonConvert.DeserializeObject(jsonWords);
Words = json.ToList();

有效主词(Valid Main Word)

首先,我们检查主要造词是否有效.验证委托给方法"(First, we check if the main coined word is valid or not. The validation is delegated to the method ‘) CheckValidity .如果是水平单词,则它将首先移动到单词的开头.(. If it is a horizontal word, then it moves first to the beginning of the word.)

while (--x >= 0)
    // First walk towards the left until you reach the beginning of the word that is already on the board.
    if (matrix[x, y] == '\0') break;

// Keep a track of where (x, y) this word started on the board.
startX = ++x;
startY = y;

例如,如果玩家将A和P放在棋盘上(已有一个CATER单词),那么我们从A开始并向左走,直到到达预期单词(CAP)的开头.请记住,BoardCellList仅包含A和P,它对C没有任何丝毫含义.(For example, if the player placed A and P on the board (there is an existing word CATER), then we start with A and walk towards left until we reach the beginning of the intended word (CAP). Remember BoardCellList has A and P only, it doesn’t have any slightest idea of C.)

然后我们开始走到单词的结尾.在步行过程中,它还会检查这是否是空白图块,或是否有高级内容.此外,它还会继续记录每个字母的分数详细信息. ‘(Then we start walking to the end of the word. During the walk it also checks if this is a blank tile, or if there is a premium content. Also, it keeps recording the score details for each individual letter. The ‘) GetPreimumContent ’方法只是检查当前的板级电池内容是否存在优质内容(2W,3W,2L,3L). ‘(’ method simply checks the current board cell content if there was a premium content (2W, 3W, 2L, 3L) there. The ‘) CheckIfBlankTile ’方法会在全局空白图块列表中检查当前单元格中是否有空白图块.逐渐地,它沿着单词走到了尽头.因此,它获得完整的单词.(’ method checks in the global blank tiles list if the current cell has a blank tile there. Gradually it walks along the word to reach the end. Thus, it obtains the complete word.)

string premium;
bool blankTile;

// Now walk towards right until you reach the end of the word that is already on the board.
for (int i = 0; x < GRID_SIZE; x++, i++)
{
    if (matrix[x, y] == '\0') break;
    chars[i] = matrix[x, y];
    premium = GetPreimumContent(x, y, boardCellList);
    blankTile = CheckIfBlankTile(x, y);
    score.Add(new IndividualScore(blankTile ? ' ' : chars[i], premium, new Point(x, y)));
}

string str = new string(chars);
str = str.Trim('\0');

然后,它检查单词是否在词典中.如果在该位置,则它进一步检查该单词是否尚未由同一位置的任何玩家(包括当前玩家)创造.可能会注意到,同一单词可以被多次创造,但是它们不能位于同一位置.(Then it checks if the word is in the dictionary. If it there, then it further checks if the word is not already coined by any player (including the current player) in the same location. It may be noted that same word can be coined more than once, however they must not be in the same location.)

if (Words.IndexOf(str) == -1)   // If the word is not found in the dictionary,
    return false;               // then return negative.

如果在词典中找到了该单词,那么我们必须检查它是否与先前在相同位置创造的同一个单词相同.如果是,那么这是一个无效的单词.(If the word is found in the dictionary, then we must check if it is the same word coined at the same place earlier. If it is, then this is an invalid word.)

foreach (PlayerDetails p in Players)
{
    foreach (TurnsWithScores t in p.ScoreDetails)
        if (t.ValidWords != null)
            foreach (ValidWordWithScore v in t.ValidWords)
                if (v.Word == str.ToUpper() && v.Axis.X == x && v.Axis.Y == y)
                {
                    existingWord = true;
                    return false;
                }
}

可能需要注意的是,我们使用了布尔值" out"变量"(It may be noted that we have used a Boolean ‘out’ variable ‘) existingWord ’.此标志确定是否应将此单词添加到无效单词列表中.如果它是板上现有的单词,则我们不会将其添加到无效单词列表中,因为它只是一个现有单词,而不是无效单词.(’. This flag determines whether this word should be added to the invalid word list or not. If it is an existing word on the board, then we don’t add it in the invalid word list as it is just an existing word, but not invalid.) 如果它是一个有效的单词,则将其添加到有效的单词列表中,其中包含每个字母的详细分数以及单词的起始位置.(If it is a valid word, then it is added to the valid word list with detailed score for each letter, along with the starting position of the word.)

validWords.Add(new ValidWordWithScore(str, score, new Point(x, y))); // Add it to the valid list.

确认有效性之后,我们需要检查它是否穿过(或碰过)现有单词(如果不是第一个单词).前面已经讨论过了.(After the validity is confirmed, then we need to check if this crossed through (or touched) an existing word (if it is not the first word). This is discussed earlier.)

有效的次要词(Valid Secondary Words)

最后,是时候检查次要单词和主要单词是否一起创造了.如果其他单词与主单词一起创建,则这些单词也应为有效单词.(Finally, it is time to check if secondary words are coined along with the main word. If other words are created along with the main word, then those should also be valid words.) 让我们通过水平放置的单词" PASCAL"进行解释.假设董事会上有LAMB和LA.玩家将P,S,C,A,L拖到板上.(Let’s explain through a horizontally placed word ‘PASCAL’. Let’s say there are existing words on the board – LAMB and LA. The player dragged P, S, C, A, L on the board.)

播放器正确地输入了主音PA​​SCAL.然而,看着板子,他/他又做了一个单词AS,它也必须是一个有效单词(无论如何还是一个有效单词).(The player made the main word PASCAL correctly. However, looking at the board, s/he made another word AS which also needs to be a valid word (which is a valid word anyway).) 为此,我们遍历P,S,C,A,L(玩家拖动的字母),看看是否有任何单词是通过它们垂直创造的. " P"上方或下方没有任何字母;因此,它已通过.接下来,找到AS;这是一个刚出生的有效单词(不是现有单词).因此,这个单词(AS)被授予当前玩家.渐渐地,我们走到最后一个字母(C,A,L)并检查每个字母.(To do this, we walk through P, S, C, A, L (the player’s dragged letters) and see if any word is coined vertically through them. ‘P’ doesn’t have any letter above or below it; so, it is passed. Next, we find AS; this is a valid word which is just born (not an existing word). So, this word (AS) is awarded to the current player. Gradually we walk up to the last letter (C, A, L) and check for each them.)

// Take a clone of the letters that were placed on the board in sorted order from left to right.
List<BoardCell> boardCells = boardCellList.Select(a => a).OrderBy(b => b.X).ToList();
int y = boardCells[0].Y;
int yBelow = y + 1;
int yAbove = y - 1;

// Check if there are letters below or above the horizontally placed word.
// The bottom row to check could be less than or equal to the last row (GRID_SIZE).
// The top row to check could be greater than or equal to the first row (0).
//if (y + 1 < GRID_SIZE)
for (int i = 0, x; i < boardCells.Count; i++)
{
    x = boardCells[i].X;
    if ((yBelow < GRID_SIZE && matrix[x, yBelow] != '\0') || (yAbove >= 0 && matrix[x, yAbove] != '\0'))
        CheckIfValidWord(x, y, WordDirectionEnum.Vertical, matrix, validWords, invalidWords, boardCellList);
}

正在还原(Reverting)

当单词无效时,将发生还原.如果玩家做出多个单词,那么所有这些单词也应该都是有效单词.如果至少一个单词无效,那么将发生还原-字母被带回机架并转向下一个玩家.(A revert happens when the word is not valid. If the player makes more than one word, then all of them should be valid words as well. If at least one word is invalid, then the revert happens – letters are taken back to the rack and turn moves to the next player.) 会发生几个同步动作.(A couple of synchronous actions takes place.) 对于黑板上画出的每个字母-(For each letter that was drawn on the board –) 1.获取信件在板上的位置.(1. Get the location of the letter on the board.) 2.在拖动之前,获取字母在其所处机架上的位置.(2. Get the location of the letter on the rack where it was staying before dragging.)

rackCell = RackCellList.Pop();
boardCell = BoardCellList.Pop();

rackCellCtl = Controls.Find($"p{rackCell.Player}l{rackCell.Cell}", true)[0]; // E.g.: p2l4
rackCellAbsLoc = rackCellCtl.FindForm().PointToClient(rackCellCtl.Parent.PointToScreen(rackCellCtl.Location));

boardCellCtl = Controls.Find($"l{boardCell.X}_{boardCell.Y}", true)[0];      // E.g.: l4_12
boardCellAbsLoc = boardCellCtl.FindForm().PointToClient(boardCellCtl.Parent.PointToScreen(boardCellCtl.Location));

3.如果任何字母是空白图块,则-(3. If any of the letters was a blank tile, then –) 一种.从全局列表中删除相应的条目’(a. Remove the corresponding entry from the global list ‘) BlankTileRackLocations ’.(’.) b.从"(b. Remove the corresponding entry from ‘) BlankTiles “列表.(’ list.) C.将飞行字母文本设置为空白字母(隐喻地,登机并登机).(c. Set the flying letter text to the blank letter (metaphorically, check in the passenger, and board the plane).) d.将机架单元的背面颜色设置为空白图块颜色(兰花).(d. Set the rack cell back colour to blank tile colour (orchid).) 4.否则,将飞行字母文本设置为板单元上的字母.(4. Else, set the flying letter text to the letter on the board cell.)

if (BlankTiles.Count > 0)
{
    RackCell c = BlankTiles.FirstOrDefault(a => a.Player == rackCell.Player && a.Cell == rackCell.Cell);
    if (c != null)
    {
        // Remove the entry from the global 'BlankTilesLocation' if the location matches.
        BlankTileRackLocations.Remove(BlankTileRackLocations.FirstOrDefault(a => a.X == boardCell.X && a.Y == boardCell.Y));

        lblFlyingLetter.Text = " ";
        BlankTiles.Remove(c);
        rackCellCtl.BackColor = BACK_COLOR_FOR_BLANK_TILE;
    }
}
else lblFlyingLetter.Text = boardCellCtl.Text;

5.如果它是中央星形单元,则将板单元的字体设置为较大的(48).(5. If it is the central star cell, then set the font of the board cell to the bigger one (48).)

if (boardCell.X == 7 && boardCell.Y == 7)
    boardCellCtl.Font = STAR_CELL_FONT;

6.如果启用了高级标记,则在板单元(如果是高级单元)上显示标记(2L,3L,2W,3W).(6. If premium markers are toggled on, then show the marker (2L, 3L, 2W, 3W) on the board cell (if it was a premium cell).) 7.否则,仅在单元格上显示高级颜色(如果它是高级单元格).(7. Else just show the premium colour on the cell (if it was a premium cell).)

// If premPut back any special content like 2L, 3W etc.
if (PremimumIdentifierToggle)
    boardCellCtl.Text = boardCell.PremiumContent.ToString();
else boardCellCtl.Text = "";                                            // Premium colour only.

8.如果此机架单元格是空白图块,则将板单元格的背景色更改为原来的颜色,然后再在其上拖动空白图块.(8. If this rack cell was a blank tile, then change the board cell back colour to what it was before dragging the blank tile on it.)

BlankTileOnBoard blankTile = BoardBlankTiles.FirstOrDefault(a => a.Cell.X == boardCell.X && a.Cell.Y == boardCell.Y);
if (blankTile != null)
{
    boardCellCtl.BackColor = blankTile.Colour;
    BoardBlankTiles.Remove(blankTile);
}

9.将信件飞回机架.(9. Fly the letter back to the rack.) 10.将矩阵中的相应单元格(10. Make the corresponding cell in the matrix to) NULL ('\ 0’).((‘\0’).)

FlyLetter(boardCellAbsLoc, rackCellAbsLoc);
rackCellCtl.Text = lblFlyingLetter.Text;

// Clear the corresponding cell in the matrix to enable next drag-drop on it.
Matrix[boardCell.X, boardCell.Y] = '\0';

分数追踪(Score Tracking)

每个回合都会记录每个球员的得分详细信息-措辞是否正确,是否通过或是否创造了无效的单词.这就是所谓的"可追溯性”-我们的工作应该在生活的各个方面都可追溯且诚实.(Each player’s score details are recorded at each turn – whether the wordings were correct, or if it was a pass or if invalid words were coined. This is what is called ‘traceability’ – our work should be traceable and honest in every sphere of life.) 为了了解得分轨迹,让我们看一下下面的DGML图.(To understand the scoring track let’s have a look at the following DGML graph.) ‘(The ‘) PlayerDetails ‘类别的对象是’(’ class has an object of ‘) TurnsWithScores “的对象是”(’ which has an object of ‘) DetailedScore ’.(’.) 在每个事件(有效的措词,无效的措辞,通过)上,都会用有效的单词(简单的字符串),当前的匝数和该匝的详细分数(如果有效的措词)记录转弯.如果当前措词中包含无效词,则详细分数为空.(At each incident (valid wording, invalid wording, pass) the turn is recorded with valid words (simple string), current turn number and detailed score of that turn (if valid wording). If there are invalid words in the current wording, then the detailed score is null.) 详细分数包含当前单词的轴信息,总得分以及在此回合中制定的实际有效单词.可能会注意到,'(The detailed score contains the axis information of the current word, the total score and the actual valid word that was formulated in this turn. It may be noted that ‘) TurnsWithScores “是”(’ is a list of ‘) DetailedScore ’;当前回合中可能有很多有效的单词,并且每个单词都会记录自己的历史记录.(’; there may be many valid words in the current turn and each one of them will have its own history recorded.)

只需将正确的数据保存在正确的位置即可.(It is just a matter of keeping the right data in the right place.) 如果失败,那就很容易-只需在当前玩家的得分详细信息中添加转弯号码,无效单词和有效单词即可.(If there is a failure, then it is easy – just add the turn number, the invalid words and the valid words in the current player’s score details.)

Players[currentPlayer].ScoreDetails.Add(new TurnsWithScores(currentTurn, $"Invalid word(s):
     {string.Join(", ", invalidWords)}.{Environment.NewLine}{Environment.NewLine}", validWords));

如果成功,那么也很容易-只需添加当前玩家的得分详细信息即可:(If there is a success, then it is easy as well – just add to the current player’s score details:)

• 转数,(the turn number,)
• 每个有效单词的得分细节,(the scoring details of each valid word that is coined,)
• 以及每个有效单词的单个字母分数.(and individual letter score of each valid word.)

Players[currentPlayer].ScoreDetails.Add(new TurnsWithScores(currentTurn, str.ToString(), validWords));

以下是对象的快照.(Following is a snap of the objects.) 玩家[0]姓名:Mehedi,总成绩存储在" TotalScore"中.(Player[0] name: Mehedi, total score is stored in ‘TotalScore’.) 到目前为止,这名球员有两个字.(Two words so far for this player.) 反过来,"(In turn 1, the ‘) DetailedScore 有效词的’会保留显示的确切信息.(’ of the valid word keeps the exact message that was displayed.) 分数细分显示在"(Score breakdown is visible in the ‘) Score ’对象.创造的有效字词记录在"(’ object. The valid word that was coined is recorded in ‘) Word ’.分数明细记录在"(’. The breakdown of the scores is recorded in ‘) Score ’对象.它保持字母的轴,高级内容(如有),字母得分和字母本身.空白图块是一个空格,没有得分值.(’ object. It keeps the axis of the letter, the premium content if any, the letter-score and the letter itself. The blank tile is a space and doesn’t have a score value.)

游戏结束(Game End)

游戏可以通过三种方式结束.(There are three ways that the game might end.)

• 游戏达到最大连续失败计数(6).(The game reaches the maximum consecutive fail count (6).)
• 袋子里没有字母了,当前玩家的架子空了.(There is no more letter in the bag and the current player’s rack is empty.)
• 袋子里没有更多的字母了,所有玩家的架子上都有剩余的字母.(There is no more letter in the bag and there are remaining letters in all the players’ racks.)

达到最大失败次数(Reaching maximum fail count)

如果连续6次失败(赔付,交换或失败的单词),则游戏结束.如果游戏以这种方式结束,则从每个玩家的总得分中扣除每个玩家机架中剩余字母的面值.这是一个简单的逻辑–遍历玩家的所有字母,对面值求和,从分数中扣除.这是通过"(If there are 6 consecutive fails (forfeits, exchanges or failed words), then the game ends. If the game ends this way, then the face-value of the remaining letters in each player’s rack is deducted from his/her total score. This is a simple logic – loop through all letters of the player, sum up the face-values, deduct from the score. This is done in the method ‘) EndGame() ’.(’.) 扣除后,得分最高的人将赢得比赛.(After deduction, whoever scores the highest wins the game.)

袋子里没有字母了,架子是空的(No more letter in bag, rack is empty)

当袋子空了并且当前玩家的架子上没有更多字母(他/他成功用完了所有字母)时,就会出现这种情况.在这种情况下,会发生两件事.(This situation arises when the bag is empty and there is no more letter in the current player’s rack (s/he successfully used up all the letters). In this case two things happen.)

• 其他玩家机架中所有字母的面值将添加到当前玩家的得分中.(the face-values of all the letters in other players’ racks are added to the score of the current player.)
• 对于其余的球员,他们的每个分数都会减去他/她自己架子上剩余的字母分数总数.(For the remaining players, each of their scores is reduced by the remaining letter score totals of his/her own rack.) 按照这种简单的算法,最高得分者就是赢家.(After this simple arithmetic the highest scorer is the winner.)

袋子里没有字母了,架子也不是空的(No more letter in bag, racks are not empty)

当袋子空了并且当前玩家的机架(以及其他玩家的机架)中剩余字母时,就会出现这种情况.可能需要注意,在这种情况下,其他玩家剩余7个字母,而当前玩家可能少于或等于7个字母.这是因为在重新填充当前玩家的架子时,包可能会变空.(This situation arises when the bag is empty and there are remaining letters in the current player’s rack (and in other player’s racks as well). It might be noted that in this scenario, other players will have 7 letters remaining while the current player might have less than or equal to 7 letters. This is because bag might become empty while refilling the current player’s rack.) 例如,假设当前玩家在当前回合中放置了5个字母(机架中还剩下2个字母),那么选择了重新填充;例如说包中只有3个字母,因此当前玩家在加注后将有(2 + 3)=5个字母.因此,情况触发了–袋子是空的,并且所有玩家的架子上都剩下字母.(For example, say the current player placed 5 letters in the current turn (2 remaining in the rack), then a refill is opted; say the bag has 3 letters only, hence the current player will have (2+3) = 5 letters after refilling. Hence the condition triggers – the bag is empty and there are remaining letters in all the players’ racks.) 在这种情况下,达到最大失败次数的逻辑相同-所有玩家的得分都将通过自己剩余的字母得分的总和而降低.(In this situation, the same logic for reaching maximum fail count applies – all the players’ scores are reduced by summation of their own remaining letter-scores.)

毛刺(Glitches)

如果您能在评论中提出任何意见,我将不胜感激.我将在以后的版本中修复.(I would be grateful if you kindly put in comments if any found. I shall fix in a later release.)

局限性(Limitations)

两种动画效果(摇晃和飞信)接连发生.但是,它涉及大量线程睡眠,并迫使该过程完成.有时根据处理器速度,这两种效果可能无法正确同步.(The two animation effects (bag-shaking and letter flying) occur one after another. However, it involves a lot of thread sleeps and forcing the process to complete. At times based on the processor speed, these two effects might not sync in properly.)

未来作品(Future Works)

该项目可以完成很多工作.(A lot of work can be done on the project.)

• 介绍定时挑战.(Introduce timed challenge.)
• 与计算机对战.这将涉及字谜算法和复杂的AI方法.(Play against computer. This would involve anagramming algorithms and sophisticated AI approaches.)
• 尽管棋盘上有很多舞蹈,但为什么不添加一些音乐:)？(While there are a lot of dances around the board, why not add some music :)?)
• 提供更好的机制来正确同步两个动画效果.(Provide a better mechanism for syncing the two animation effects properly.)
• 添加定时挑战.(Add timed challenges.)
• 将游戏扩展到不同的Unicode语言.为不同的Unicode语言创建规则和分数.(Extend the game to different Unicode languages. Create rules and scores for different Unicode languages.)
• 要与Google字典网络服务链接(我不知道是否有任何服务;尚未对其进行任何研究-尽管还有一些其他付费服务).造词时可以调用API以获取含义.例如,个人而言,我不知道有一个有效的词" AA",意思是"玄武岩熔岩形成了非常粗糙,锯齿状的块状,质轻的泡沫"(来自Google).我只是在游戏中尝试过,它是正确的(这只是uke幸).因此,最好理解其含义(即使某些尝试可能是纯粹的骗局).(To link with Google dictionary web service (I don’t know if there is any; haven’t done any research on it yet – there are some other paid services though). The API can be called to fetch the meaning when a word is coined. For example, personally I didn’t know there is a valid word ‘AA’ that has a meaning ‘basaltic lava forming very rough, jagged masses with a light frothy texture’ (– from Google). I just tried it in the game and it was correct (it was just a fluke). So, it would be better to know the meaning (even if some of the attempt might be pure flukes).)
• 逻辑可能存在重叠–我认为某些逻辑或数据结构是出于不同目的而重复的.通过使它们通用,可以识别并解决这些问题.(There is possibility of logic overlaps – I believe some of the logic or data structures are duplicated for a different purpose. These can be identified and resolved by making them generic.)
• 这不是完全面向对象的.重点更多地放在建立逻辑上,因此它变得更具程序性.代码的不同部分可以更加精简,并与优雅和更新的OOP概念和设计模式保持一致.(This is not completely object-oriented. Focus was more on building up logic, hence it rather became procedural. Different portions of the code could be more streamlined and aligned with elegant and updated OOP concepts and design patterns.)
• 除了使用鼠标拖放外,还可以使用键盘从机架中复制字母,然后只需单击鼠标即可将其放到其中.这样可以节省时间吗？(Instead of mouse drag-drop, use keyboard to copy the letter from the rack and simply mouse-click on the cell where to drop it. This might save time?)
• 通过撤消(CTRL + Z)将字母飞回机架作为练习,供读者阅读.试试吧(Flying letters back to rack by undoing (CTRL+Z) is left as an exercise for the reader. Let’s try it.)
• 初始吉祥物选择中的吉祥物拖放操作仅是一次性操作.没有撤消选项.这留给读者练习,以申请(CTRL + Z)取回吉祥物并选择其他吉祥物.(Mascot drag-drop in the initial mascot selection is a one-time operation only; there is no UNDO option. This is left as an exercise to the reader to apply (CTRL+Z) for taking back a mascot and choosing another.)
• 如果有多个玩家画出的字母最接近" A",则执行重绘,而不是将启动时间授予遇到第一个使用最接近字母的玩家.(If more than one player draws the same letter that is closest to ‘A’, then perform a redraw instead of awarding the start-up to the first player encountered clockwise with the closest letter.)

基本原理摘要(Rationales Summary)

何时收缩袋(When to shrink the bag)

可能会产生疑问,为什么在当前回合结束时或在没收行李时将行李袋缩小？为什么抽签后它不立即收缩？原因是交流.交换所返回的所选字母与提取字母的位置相同.因此,如果在绘制后立即将包缩小,则返回的字母将没有空间可移动.那将是混乱的混乱和世界的尽头(游戏结束).(Question may arise why the bag is shrunk at the end of the current turn or a forfeit? Why doesn’t it shrink immediately after a letter draw? The reason is the exchange. An exchange returns the selected letters in the same index of the bag from where they were drawn. So, if the bag is shrunk immediately after drawing, then the returning letters have no space to move in. That would be a hectic chaos and end of the world (end of the game).)

堆栈,队列,列表的使用(Use of Stack, Queue, List)

这些已在相关章节中进行了说明.仅使用一个队列.否则可以使用列表.另外,可以借用现有列表或堆栈来作为队列"(These are already explained in the relevant sections. Only one queue is used; a list could be used otherwise. Also, an existing list or stack could be borrowed for the queue ‘) DrawnLetters ’;这个仅用于确定第一个玩家.(’; this one is only used for determining the first player.)

使用四个绿色按钮(Use of four green buttons)

再次可以通过仅一个按钮转动的一个按钮来完成这些操作.单击时,可以显示相应的分数详细信息.这是留给读者的简单练习.(These again can be accomplished with one button only which moves according to turns. When it is clicked the corresponding score details can be displayed. This is a simple exercise left for the reader.)

兴趣点(Points of Interest)

该项目与计时器一起使用.计时器是与线程无关的组件.意味着,它可以独立运行,其他活动可以同时进行.但是,动画需要相反的内容.其他线程需要停止/暂停直到计时器结束.例如,在行李摇晃定时器完成行李摇晃之前(即,直到该定时器停止运行),字母才应飞行.(This project works with timers. Timer is a thread-independent component. Means, it runs on its own where other activities can take place simultaneously. However, the opposite was needed for the animation; other threads needed to stop/pause until the timer finishes. For example, the letters should not fly until the bag-shaking timer finishes shaking bag (i.e., until that timer stops).) 另一个兴趣点是控件的绝对位置.机架单元和板单元在面板内部.如果直接使用它们的轴,则相对于容器面板而不是相对于窗户进行测量.这就是为什么需要绝对位置的原因.例如:(Another point of interest is a control’s absolute position. The rack cells and the board cells are inside panels. If their axis is used straight away, then that is measured relative to the container panels, not relative to the window. That is why an absolute location needs to be in place. For example:)

// Obtain absolute location of the rack's cell from the top left of the window.
cellAbsLoc = ctl.FindForm().PointToClient(ctl.Parent.PointToScreen(ctl.Location));

致谢(Acknowledgements)

认可各种站点和组织将其图像用作吉祥物,包括Ubisoft(用于使用波斯王子和Beyond Good and Evil吉祥物),Microsoft(用于刺客信条吉祥物),Pyro和Eidos(用于绿色贝雷帽吉祥物),Universal Pictures(用于Gru和Agnes吉祥物),任天堂(用于Mario吉祥物),迪斯尼(用于Bolt,Up和Zootopia吉祥物),环球影业(用于Peabody先生和Sherman吉祥物),20(Acknowledging various sites and organizations for using their images as mascots including Ubisoft (for using Prince of Persia, and Beyond Good and Evil mascot), Microsoft (for Assassin’s Creed mascot), Pyro and Eidos (for Green Beret mascot), Universal Pictures (for Gru and Agnes mascot), Nintendo (for Mario mascot), Walt Disney (for Bolt, Up, and Zootopia mascot), Universal Pictures (for Mr. Peabody and Sherman mascot), 20)日(th)Century Fox(用于Yoda吉祥物)和Universal Studios(用于Tiger Boo吉祥物).(Century Fox (for Yoda mascot), and Universal Studios (for Tiger Boo mascot).) 吉祥物是我一生中的一些随机选择.(The mascots are some random picks from moments of my life.)

免责声明(Disclaimer)

该项目以"莺"命名,“莺"是一只可爱的小鸟,带有可爱的小推文-鼓励玩家鸣叫(可爱)小词.它(标题)也可以补充(The project is named after ‘warbler’ which is a cute little bird with cute little tweets - encouraging the players to tweet (cute) little words. It (title) also complements) Crossworder先生(Mr. Crossworder) ;他们每个人都有自己的优点.不再存在性别偏见.扯平了 :)(; each of them stands on their own merits. There is no gender bias anymore. We are even :)) 该项目使用了两个图像和一个gif.这些使项目和可执行文件的大小变大了.我很抱歉为下载项目和可执行文件增加了一些带宽需求.我不想为了获得高下载带宽的一次性要求而牺牲魅力.(The project uses a couple of images and one gif. These made the size of the project and the executable a little bigger. My apologies for a little more bandwidth requirement for downloading the project and the executable. I didn’t want to sacrifice the glamour touches for one-time requirement for high download bandwidth.) 我无法测试游戏结局的优势.如果有人玩到最后并且发现任何小故障,请在评论中提及它,我将不胜感激.(I couldn’t test the edge cases for game-ending. If anybody plays till the end and finds any glitches, I would be grateful if you kindly mention it in the comments.) 该项目纯粹是出于教育目的,对逻辑开发进行实验,并鼓励出于实际目的考虑数据结构和算法.它还可以用于逻辑开发,以查找字符串中的结构模式.从各种单词制作游戏(例如拼字游戏,涉水游戏,错字游戏,古德勒,qwirkle等)和填字游戏规则中,借鉴了措辞,得分,木板,遗忘,规则等各个方面.(The project is purely for educational purposes that experiments on logic development and encourages to think of data structures and algorithms for practical purposes. It also works on logic development for finding structural patterns in strings. Various aspects like wording, scoring, board, forfeits, rules are borrowed from various word-making games (e.g. scrabble, dabble, typo, quiddler, qwirkle etc.) and crossword rules.)

有趣的坑洼(Funny Pothole)

游戏开始时,如果您连续6次失败(只需按6次``通过’'),则仍然会根据常规游戏结束规则宣布获胜者.没有规则说,董事会上没有一个字会意味着没有人能赢.虽然这很有趣,但这与生活的深刻哲学洞察力有关-世界上有些人可以在不动肌肉的情况下得分(或赚钱)(没关系,在开玩笑).(When the game starts and if you commit 6 consecutive fails (just press ‘pass’ 6 times), then a winner will still be declared according to the regular game-ending rules. No rule says that, not a single word placed on the board would mean nobody can win. Although this is funny, but this relates to a deep philosophical insight of life - some people in the world can score (or earn) without moving a muscle (never mind, joking).)

参考文献(References)

开源词典(Open-source dictionary) 控件的绝对位置(Absolute location of a control) 鼠标单击的Ctrl修饰符(Ctrl modifier with mouse click) 在线图片编辑器(Online image editor) ASCII图表(ASCII chart) C#.NET中的完整单词益智游戏(A complete word puzzle game in C# .NET) Winforms的响应式设计技术(A responsive design technique for Winforms) 包图像(Bag image) 鞭炮图片(Firecrackers image) 发明人的形象(Inventor’s image) Crossworder先生(Mr. Crossworder) 艾格尼丝的形象(Agnes’s image) 螺栓的形象(Bolt’s image) 格鲁的形象(Gru’s image) 波斯王子形象(Prince of Persia image) 马里奥男子形象(Mario Man image) 卡尔`弗雷德里克森图片(Carl Fredrickson image) 刺客信条图片(Assassin’s Creed image) 汤姆和杰里图片(Tom & Jerry image) 谢尔曼的形象(Sherman’s image) 尤达形象(Yoda image) Zootopia图片(Zootopia image) 老虎嘘图像(Tiger Boo image) 玉的形象(Jade’s image) 罗素的形象(Russell’s image) 绿色贝雷帽的形象(Green Beret’s image) 鞭炮图片(Firecrackers image) 绿色按钮(Green button) 剪刀图标(Scissors icon)

历史(History)

2019年4月11日:首次发布.(11 April 2019: First release.)

许可

本文以及所有相关的源代码和文件均已获得The Code Project Open License (CPOL)的许可。