线索游戏(C#2010)（译文）

原文地址：https://www.codeproject.com/Articles/96869/The-Game-of-Clue-C-2010

原文作者：Christ Kennedy

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

前言

You are a suspect!

你是嫌疑犯!

• 下载源代码-3.67 MB(Download source code - 3.67 MB)

线索游戏(The Game of Clue)

根据(According to) 创意搜寻器(Idea Finder) ,ClueDo的游戏是由安东尼欧内斯特普拉特(Anthony Ernest Pratt)发明的,并于1947年在英国获得了专利,然后由Waddington Games购买,然后在1949年帕克兄弟(​​Parker Brothers)购买了美国的版权.从那以后,游戏一直是世界上雨天和小屋橱柜的中流tay柱.这个谋杀之谜有几种PC版本,当我遗忘了我在商店货架上看到的最后一个副本,然后又找不到另一个副本时,我去了最近的旧货店并购买了旧的木板副本.游戏的价格为2美元,并且大约一个月前就开始在此项目上进行,它看起来很酷.(, the game of ClueDo was invented by Anthony Ernest Pratt and patented in England in 1947, then purchased by Waddington Games before the U.S. rights were bought by Parker Brothers in 1949. The WhoDunnit? game has been a mainstay of rainy days and cottage cupboards around the world ever since. There have been several PC versions of this murder mystery, and after passing up the last copy I’d seen on a store shelf and then failing to find another one again, I went to the nearest thrift shop and bought a used copy of the board game for $2, and started on this project about a month ago, and it looks pretty cool.)

玩游戏(Playing the Game)

如果您只想演奏以前喜欢的并且已经有(If all you want to do is play your old favourite and you already have) 微软的C#2010(Microsoft’s C#2010) 启动并运行,那么您所要做的就是下载上面的源代码,并在谋杀当天将自己送入Boddy先生的大厦.提示时进行选择,您可以播放任何喜欢的嫌疑犯.(up and running, then all you need to do is download the source code above and let yourself into Mr. Boddy’s Mansion on the day of the murder. You can play any suspect you like by making your selection when prompted.)

这是一款单人游戏,因此其他所有玩家均由计算机的人工智能控制,您可以通过菜单选项->设置AI进行设置.(It’s a one-player game, so the other players are all controlled by the computer’s Artificial Intelligence, which you can set via the menu Options->Set-AI.)

设置好此菜单后,您可以通过单击角色名称在各个AI级别之间循环.如果您可以用自己的"智能"做同样的事情,那将是很好的,但是即使您正在玩Mustard,并且将Mustard的AI设置为(Once you have this menu up, you can cycle through the various AI-levels by clicking on the character’s name. It would be nice if you could do the same thing with your own ‘intelligence’, but even if you’re playing Mustard and you set Mustard’s AI to)天才(genius),您仍然需要自己完成所有工作.(, you’ll still have to do all the work yourself.) 还有一个叫做(There’s also something called)**自动进行(Auto-Proceed)**这是(that’s part of the)**速度(speed)**控件,您可以通过菜单选项->速度访问.(controls, which you can access through the menu Options->Speed.)

在默认设置下(In the default setting)**,自动进行(, Auto-Proceed)**会以与您在桌子周围与人一起玩时类似的方式推进游戏,因此很难跟上并仔细记笔记.您可能想在第一次播放时将其关闭,然后手动点击"(will advance the game in a way similar to when you’re playing with people around a table so that it is difficult to keep up and take careful notes. You may want to switch this off the first time you play, and manually click the ‘)好(OK)‘按钮可在您进行侦查时移动游戏.这把我们带到了(’ button to move the game along while you do your sleuthing. Which brings us to the)**笔记本(Notebook)**在游戏板的右边.(on the right of the game board.)

记笔记(Keeping Notes)

在上图中,您会注意到一些事情.首先,左边的名称是游戏卡的名称,这些游戏卡分为可疑卡,武器卡或房间卡.看一下图像的左边缘,您会看到犯罪嫌疑人持有的三张卡;在此特定示例中:左轮手枪,音乐学院和台球室.在名称的右侧,您可以看到六个彩色框.这些盒子是用户控制的.您可以右键单击或左键单击它们,以循环显示每个彩色框可以容纳的四个可能值:(In the image above, you’ll notice a few things. First, the names on the left are the names of the game cards sorted out into either Suspect-Cards, Weapon-Cards, or Room-Cards. Take a look at the left edge of the image, and you’ll see the three cards your suspect is holding; in this particular example: Revolver, Conservatory, and Billiard Room. To the right of the names, you can see six colored boxes. These boxes are user-controlled. You can either right-click or left-click them to cycle through the four possible values each colored box can hold:)X(X),(,)检查(check),(,)？(?), 要么(, or)空白(blank).每个嫌疑犯都有一个颜色,并且在游戏开始时会自动设置您自己的嫌疑人的盒子,以帮助您前进. X表示嫌疑犯肯定会(. There’s a color for each suspect, and your own suspect’s boxes are automatically set at the beginning of the game to help you along. Xs mean that suspect definitely does)不(not)拥有那张卡,一张支票表示他有,而空白则表示您不知道这两种方式,还有一个？表示您认为他可能会.这应该足以帮助您解决难题.(have that card, and a check means he does, while a blank means you have no idea either way, and a ? means you think he might. This should be plenty to help you solve the puzzle.) 让我们看一下游戏板.(Let’s look at the game board.)

您可以清楚地看到9个房间和大理石瓷砖.在上图中,两个角色Scarlet小姐和Col. Mustard小姐扮演了开幕式的角色,并从各自的出发地向房间走去.游戏的目的是在不同房间之间旅行(You can clearly see the 9 rooms and the marble tiles. In the image above, the two characters Miss Scarlet and Col. Mustard have played their opening turns and stepped away from their respective start locations towards the rooms. The object of the game is to travel from room to room making)**意见建议(Suggestions)**并让其他玩家(像您这样的怀疑者)向您展示他们的牌.弄清楚它们都有什么卡后,您应该知道剩下的三张卡已经分开,现在剩下的三张卡位于棋盘中间,并赢得了比赛.(and getting other players (suspects like yourself) to show you their cards. When you’ve figured out what cards they all have, you should know what three cards have been separated from the rest and now rest in the middle of the board, and win the game.) 控制面板在笔记本计算机的右侧.(The control-panel is on the right on your notebook.)

并由一些(and consists of a few) 脉冲按钮(Pulse-Buttons) 给你(for you to either)滚死(Roll the die),(,)提个建议(Make a Suggestion), 要么(, or)轮到你了(End your turn),这些都是不言自明的.在这些按钮下方,有一个骰子盒,骰子在该骰子盒中滚动(这是方形的东西,上面有斑点!).而且,在骰子盒下方是您的终极按钮(, which are all self-explanatory. Below these buttons, you have the die-box where the die (that’s the square thing with spots on it!) is rolled. And, beneath the die-box is your ultimate button)控诉(Accuse),这就是使某人的生活真正困扰您所需要的.(, which is all you need to make someone’s life a real bother.)

给一个建议(Making a Suggestion)

在回合开始时,您将有机会立即提出建议(如果其他玩家叫您进入新房间提出建议),或者您必须搬出房间.无论哪种情况,只要(At the beginning of your turn, you’ll either get a chance to suggest right away (if some other player summoned you into a new room to make their suggestion), or you’ll have to move out of a room. In either case, whenever the)**建议(Suggestion)**按钮已启用,您有权提出新建议,并且每次进入房间时都会发生.尽可能多地提出建议可能是一个好主意.(button is enabled, you’re entitled to make a new suggestion, and that’ll happen every time you enter a room. It’s probably a good idea to make suggestions every chance you get.)

单击后,(Once you’ve clicked the)**建议(Suggest)**按钮,您的游戏面板将如上图所示.提出建议时,您必须建议您所在的房间,因此您唯一的选择是(button, your game board will look like the image above. You must suggest the room you’re in when making a suggestion, so your only options are the)**WHO(Who)**和(and the)**怎么样(How)**关于它.要做出选择,您只需单击犯罪嫌疑人的脸部和您想要建议的武器的图像,然后在做出决定后,图像将(about it. To make your choice, you simply click on the face of the suspect and the image of the weapon you want to suggest, and when you’re done deciding, the images will) 旋转(rotate) 定位点击(into position; click the)**好(OK)**准备就绪时,该按钮会显示在"气泡"底部.(button that appears on the bottom of the ‘Bubble’ whenever you’re ready.) 此时,(At this point, the)**建议(Suggestion)**需要是(needs to be)久经考验(Proven).所以玩家(. So the player)在你的左边(on your left)(或者至少是您坐在桌子旁的情况下,他会在那里)将不得不通过向您显示所要求的任何卡片来试图反驳您的建议.如果他们没有卡,他们会告诉您:((or at least that’s where he’d be if you were sitting around the table) will have to try to disprove your suggestion by showing you any of the cards you’re asking for. If they don’t have a card, they’ll tell you so:)

如果她确实有一张牌,她会告诉你她所拥有的,这将是你的建议的结尾,但是每当其他玩家提出建议时,他们和反对建议的人就是桌子上唯一的人知道正在显示什么卡.所有其他玩家都必须尝试通过演绎和推理来弄清楚这是什么牌.(If she does have a card, she’ll show you what she has and that’ll be the end of your suggestion, but whenever another player is making a suggestion, they and the person disproving their suggestion are the only people around the table who know what card is being shown. All the other players have to try and figure out what card it is by using deduction and reason.)

在游戏过程中,可能会有几次其他人会提出建议,现在该轮到您尝试反驳了.当您无法拒绝建议时,将显示一条横幅,告诉您"您没有卡",或者如果可以,同一横幅将显示您确实有卡,并会显示可以显示的卡.在这里,如果选中了自动进行设置,则即使您没有或只有一张牌,游戏也将继续运行而不会受到干扰,但是即使您没有关闭自动进行选项,游戏也会停止并等待您当您有多张建议的卡牌时,选择要向玩家显示建议的卡牌.(It will happen several times during the game that someone else will make a suggestion and it will be your turn to try to disprove it. When you cannot disprove a suggestion, a banner will appear telling you “you have no card”, or if you can, the same banner will say that you do have a card and it will show you what cards you can show. Here, if the auto-proceed setting is checked, the game will go on without your interfering if you have none or only one card, but even if you have not shut off the auto-proceed option, the game will stop and wait for you to pick which card you want to show the player making the suggestion when you have more than one of the cards being suggested.)

秘密通道(Secret Passages)

在掷骰子之前,首先要考虑是否要使用(Before you roll the die, first consider whether you want to use a)秘密通道(Secret Passage).秘密通道位于转角房间,可让您在不滚动模具的情况下全盘旅行.因此,如果您在房间里,并且想去对面的角落,则需要使用秘密通道.为此,请单击您所在房间中出现的彩色正方形.(. The secret passages are located in the corner rooms, and let you travel across the board without rolling the die. So, if you’re in a room and you want to go to the opposite corner, you’ll then want to use the secret passage. To do so, you click on to the colored square that appears in the room that you’re in)之前(before)滚动模具.下图显示了芥末上校回合开始时的游戏板,他尚未决定是否要掷骰子或使用秘密通道.您仍然可以看到角落的黄色正方形,表示芥末上校可以选择使用秘密通道,然后从休息室进入音乐学院,而不是掷骰子.(rolling the die. The image below shows the game-board at the beginning of Col. Mustard’s turn, and he has not yet decided whether he wants to roll the die or use the secret passage. You can still see the the yellow square in the corner indicating that Col. Mustard has the option of using the secret passage and go to the Conservatory from the Lounge rather than roll the die.)

来吧!(Let’s Roll!)

要滚动模具,请单击(To roll the die, you click the)**滚(Roll)**按钮.当滚动模具动画停止时,游戏板将在所有可以移动的大理石瓷砖和门上放置彩色方块,从而显示您可以移动的位置.(button. When the roll-die animation stops, the game board will display where you can move by placing colored squares on all marble tiles and doors where you can go.)

上图显示了Col. Mustard在比赛开始时掷6时的移动选项.只需单击游戏板上,芥末上校将移动到您告诉他的位置.(The image above shows the move options for Col. Mustard when he rolls a 6 at the start of the game. Just click on the game board, and Col. Mustard will move to wherever you told him to.)

我指责!(I Accuse!)

当您提出了足够的建议并想出所有办法后,继续进行指责并结束游戏,但是要小心^如果您指责不当,您将被淘汰出局,必须观看AI,直到其他侦探解决为止博迪先生的神秘谋杀案.要进行指控,您只需点击(When you’ve suggested enough and have it all figured out, go ahead and make your accusation and close the game, but be careful… if you accuse incorrectly you’ll eliminate yourself and have to watch the AI until some other sleuth solves Mr. Boddy’s mysterious murder. To accuse, you only need to click the)**控诉(Accuse)**按钮在右侧的模具盒下方.(button below the die-box on the right.)

这里的情况有所不同,因为您可以指控任何地方的任何人使用任何武器.因此,您实际上不必在任何特定房间中,这意味着您可以选择您认为是犯罪现场的任何房间.上图为您显示了指控选项,您可以像选择建议一样通过单击适当的图像进行选择.要取消指控,请点击(Things are a little different here in that you can accuse anyone anywhere with any weapon. So you don’t actually have to be in any specific room, which means you can select whatever room you think is the crime-scene. The image above shows you the accuse options, and you can make your pick by clicking the appropriate images like you did with your suggestions. To cancel your accusation, click the)**控诉(Accuse)**读取时再次按下(button again when it reads)取消指控(Cancel Accusation),您可以大声疾呼,让别人当英雄.或者,如果您有果汁,请单击屏幕中间的那个大红色脉冲按钮,查看您是A还是废物!(, and you can wuss-out and let someone else be the hero. Or, if you’ve got the juice, click that big red pulsing button in the middle of the screen and see if you’re an Ace or a Waste!)

代码(The Code)

减法过程(The Marblation Process)

这个项目写起来很有趣,并且一直很顺利,但是第一个问题是电路板本身.游戏中出现的所有图像都是从互联网上下载的(我真正吸引自己的唯一东西就是一块奶酪!).但是我没有可用于游戏的棋盘本身的图片,因为图形动画要求每个图块都完美对齐(如果我想以简单的方式做事),以方便放置可疑图像在他们适当的地方.因此,我必须自己绘制游戏板…好吧,游戏板(This project was a lot of fun to write, and it went pretty well all the way through, but the first problem was the board itself. All of the images that appear in this game were downloaded off the internet (the only thing I actually drew myself was the piece of cheese!). But there weren’t any pictures of the board itself that I could use for the game since the graphics animation required each tile to be perfectly aligned (if I wanted to do things the easy way) to facilitate the placing of the images of the suspects in their proper places. For this reason, I had to draw the game board myself… So, OK, the game board)和(and)一块奶酪.这实际上比您想象的要难.对于大理石瓷砖,我将所有空白瓷砖都涂成黄色,然后一次将几块不同的瓷砖涂成白色,同时将整个透明地图(白色瓷砖)剪切并粘贴到大理石板上的巨型图像上,每次都白掉当我粘贴最新的图像之前,先添加一些新瓷砖,然后拾起大理石,直到所有瓷砖都铺上大理石为止.将它们全部淘汰掉,然后将木板粘贴到大理石板上看起来并不酷,因为那样一来,整个地板在其后面将只有一个大理石图像.这样更好.(the piece of cheese. This was actually harder than you’d think. For the marble tiles, I painted all the blank tiles yellow, and then whited-out a few disparate tiles at a time while cutting and pasting the entire transparent map (white tiles) onto a mega image of a marble slab, each time whiting out a few new tiles and picking up marble when I pasted the latest image until all the tiles were marbled. Whiting them all out and pasting the board onto a marble slab wouldn’t look so cool, because then the whole floor would have had a single marble image behind it. This is way better.)

移动碎片(Moving the Pieces)

为了跟踪犯罪嫌疑人可以继续移动的瓷砖以及每个房间的尺寸,我使用MS-Paint绘制了一张微型地图,描绘了游戏地板,每个像素相当于一个瓷砖.这是图片:(To keep track of which tiles the suspects can move on as well as the dimensions of each room, I put together a miniature map using MS-Paint depicting the game’s floor, where each pixel is equivalent to a single tile. Here’s the image:)

可能有更好的方法来执行此操作,但是与以数据库格式直接将其直接编写成代码相比,通过这种方法可以更好地可视化游戏数据.白色像素是(There’s probably a better way to do this, but doing it this way allowed me to visualize the game’s data better than if I had written it directly into code in a database format. The white pixels are)**大理石瓷砖(marble tiles)**在游戏板上,红色瓷砖是房间,黑色瓷砖是不可及的,蓝色是门.此处要做的困难的事情是"编程"图像中的门像素以包含诸如(on the game board, the red-tiles are rooms, black tiles are inaccessible, and the blue ones are doors. The difficult thing to do here was ‘program’ the door-pixels in the image to contain information like) RoomID 和(and) dirDoor .去做这个:(. To do this:)

blue is not quite so blue, but neither should you
                 a poem by Christ Kennedy

(我已经向CodeProject申请成为他们的在线诗人获奖者,但尚未收到他们的回音;我所有粉丝的请愿书将大大提高该网站最终拥有真正需要的合适诗人的机会)((I’ve applied to the CodeProject to become their on-line poet-laureate, but haven’t yet heard back from them; a petition from all my fans would greatly improve the chances that this site finally has the proper poet it truly needs.)) 迷你地图上的蓝色像素确实保留了此信息.与所有像素一样,蓝色像素中的蓝色由四个字节大小的变量定义:(The blue pixels on the mini-map do hold this information. The color blue in the blue pixels, like all pixels, is defined by four byte-sized variables:) R (红),((red),) G (绿色),((green),) B (蓝色),以及((blue), and) A (Α).尽管所有蓝色门的B分量都具有相同的255,但是((Alpha). Though the blue doors all have the same 255 for the B component, the) R 和(and) G 价值观持有(values hold the)**出口方向(egress direction)**和(and)**房间号(room ID)**值.您可以在(values, respectively. You can see this in the) classSuspect 的功能如下图所示:(’s function shown below:)

/// <summary>
/// uses the 24x24 pixel bitmap bmpClueFloor to set up 2d array describing the game map.
/// each pixel represents a square on the board.
/// the pixel color components (Red, Green, Blue) determines the type of tile.
/// Marble Tile (corridors) : R=255, 
///                           G=255, 
///                           B=255                          (white).
/// Illegal square          : R=0, 
///                           G=0, 
///                           B=0                            (black).
/// Room                    : R=255, 
///                           G = ROOM ID NUMBER (study =0, 
///                               hall =1, ... billiard room = 7, library =8), 
///                           B=0                            (variant of Red).
/// Door                    : R=egress direction (0=north, 1=east, 
//                                     2=south, 3=west, 4=secretpassage), 
///                           G=Room ID, 
///                           B=255                          (variant of Blue).
/// e.g. the marble tile south of the door
///      (6,4 in 2d array) to the study is white (0,0,0).
///      the first tile into the study(roomId=0) is considered a door-tile 
///      facing south(dir=2) therefore tile (6,3 in 2d array) is colored (2,0,255).
///      the top-left-most tile (0,0) is the study's secret passage
///      to the kitchen(roomID=4) therefore its tile is colored(4,4,255).
///      the right-bottom-most tile (23,23) is the kitchen's secret passage
///      to the Study(roomID=0) therefore its tile is colored (4,0,255).
/// </summary>
void initFloor()
{ // static floor tiles 
    Bitmap bmpFloorTiles = new Bitmap(Clue_CS2010.Properties.Resources.ClueFloor);
    cFloor = new classFloor[bmpFloorTiles.Width, bmpFloorTiles.Height];
    for (int intX = 0; intX < bmpFloorTiles.Width; intX++)
        for (int intY = 0; intY < bmpFloorTiles.Height; intY++)
        {
            //if (intX == 0 && intY == 23)
            //    MessageBox.Show("stop initFloor()");
            cFloor[intX, intY] = new classFloor();
            Color clrTile = bmpFloorTiles.GetPixel(intX, intY);
                if (clrTile.R == 255 && clrTile.G == 255 && clrTile.B == 255)
            { // white = tile
                cFloor[intX, intY].eType = enuFloor.tile;
            }
            else if (clrTile.R == 0 && clrTile.G == 0 && clrTile.B == 0)
            { // black = invalid
                cFloor[intX, intY].eType = enuFloor.invalid;
            }
            else if (clrTile.B == 255)
            { // blue = door : R = direction door exits room, G = roomID#
                cFloor[intX, intY].eType = enuFloor.door;
                cFloor[intX, intY].dirDoor = (enuDir)clrTile.R;
                cFloor[intX, intY].eRoom = (enuRooms)clrTile.G;
            }
            else if (clrTile.R == 255)
            { // red = room : G = roomID#
                cFloor[intX, intY].eType = enuFloor.room;
                cFloor[intX, intY].eRoom = (enuRooms)clrTile.G;
            }
            else
                MessageBox.Show("this should not happen");
        }
}

房间也有颜色代码(红色像素),但事实证明这是不必要的,因为犯罪嫌疑人仅沿着瓷砖移动然后进入房间,当他们进入房间时,将它们绘制在指定的位置围绕一个中心点,因此红色的图块也可能是黑色的(尽管这样会使地图的可视化变得更加困难).无论如何,一旦(There’s also color-code for the rooms (red pixels), but that turned out to be unnecessary since the suspects only travel along tiles and then are inside a room, and when they’re inside a room, they are drawn at their assigned locations around a central point so the red tiles may as well be black (though that would make it harder to visualize the map). In any case, once this) cFloor 设置了数组,并且我们将地板设置为一种易于读取代码的数据格式,其余的部分非常简单.(array is set and we have our floor set up in a data format which the code can easily read, the rest of it is quite simple.) 好吧,实际上,还有其他一些问题.(Well, actually, there were a few other problems.) 玩家控制的犯罪嫌疑人和AI控制的犯罪嫌疑人使用几乎相同的代码,并且当AI玩家轮到移动并决定掷骰子时,或者当人类玩家按下掷骰子时,也会发生相同的事情,死按钮:死了!并且当该动画停止时,程序必须确定允许该特定嫌疑犯进入的正方形.为此,它使用一种称为(Both the player-controlled suspects and the AI-controlled suspects use much the same code, and the same thing happens when it’s an AI player’s turn to move and it decides to roll the die, or when it’s the human player who presses the roll-die button: the die is cast! And when that animation stops, the program has to decide what squares that particular suspect is allowed to go to. To do this, it uses an algorithm called)广度优先搜索(Breadth First Search),我在之前的文章中对此进行了介绍:(, which I describe in an earlier article:) 战地模拟器(Battlefield Simulator) .从本质上讲,它一步一步地从犯罪嫌疑人的当前位置移开,跟踪其在每一步踩踏时可以走到哪里,同时每步进一步走一步,直到达到极限(掷骰结果),同时始终保持在称为"数组"的阵列中跟踪犯罪嫌疑人的位置:(. Essentially, it moves step by step away from the suspect’s current location, keeping track of where it can go at each round of stepping, while stepping one step further each round, until it reaches the limit (die roll result), all the while keeping track of where the suspect can go in an array called:)

public classSearchElement[,] cSEAllowableMoves;

如下所示的类别:(of the class shown below:)

public class classSearchElement
{
    public Point pt;
    public int intSteps;
    public int intTurns;
    public int intCost;

    public enuDir SrcDir;
    public classSearchElement next;

    public void set(Point PT, int Cost, enuDir sourceDirection)
    { set(PT, sourceDirection, Cost, 0); }

    public void set(Point PT, enuDir sourceDirection, int Steps, int turns)
    {
        pt = PT;
        SrcDir = sourceDirection;
        intSteps = Steps;
        intTurns = turns;
        intCost = intTurns * 3 + intSteps;
    }
}

由于数组已初始化为仅包含任何内容(Since the array is initialized to contain nothing but) null 值(请注意,所有先前的元素都已插入到链表中,以便下次搜索时可以将其回收),当玩家(或怀疑AI的人)在屏幕上单击时,(values (note that all the previous elements are inserted into a linked list so that they can be recycled the next time a search is made), when the player (or AI-suspect) clicks on the screen, the) pictureBox 点击事件处理程序测试与点击的屏幕区域相对应的图块是否为(click-event handler tests if the tile corresponding to the area of the screen that was clicked is) null ;如果是,则忽略该点击;如果不是,则它知道该图块是该嫌疑人要移动到的有效位置.(; if it is, then that click is ignored; if it isn’t, then it knows that that tile is a valid place for that suspect to move to.) 然后,当知道玩家想去的地方时,它会在(Then, when it knows where the player wants to go, it does another similar breadth first search in the) classSuspect 功能(function) shortestPath() 使用相同(using the same) classSearchElement 如上图所示,从目的地到当前位置,同时跟踪其行进路线(通过(shown above and stepping from the destination to the current location, while keeping track of the path along which it travels (via the) SrcDir 可变的(variable in) classSearchElement ).然后动画开始.(). Then the animation begins.)

模式àla模式(Mode à la mode)

该项目中最重要的变量之一是(One of the most important variables in this project is) eMode 类型(of type) enuMode ,如下所示:(, shown below:)

public enum enuMode 
{
    idle,
    dealCards,
    Accuse,
    Accuse_Animation,
    chooseCharacter,
    warnPlayerNextTurn,
    beginTurn,
    gameOver,
    rollDie_begin,
    rollDie_animate,
    rollDie_end,
    showAllowableMoves,
    animateMove,
    Suggest,
    AISuggestionComplete,
    animateIntroduction,
    animateSummonSuspect,
    animateSummonWeapon,
    animateSecretPassage,
    respondToSuggestion,
    playerChoosesCardToShow,
    playerTurnIdle,
    endTurn,
    any
};

每当(Whenever) tmrDelay 启用并打勾时,其事件处理程序将检查游戏处于哪种模式,然后再决定下一步需要做什么.当犯罪嫌疑人从一个砖块移动到下一个砖块,或通过门进入或离开房间时,(is enabled and ticks, its event handler checks to see what mode the game is in before deciding what needs to be done next. When the suspect is moving from one tile to the next, or entering or leaving a room by a door, then the) eMode 变量设置为(variable is set to) animateMove 程序的流程属于函数(and the flow of the program falls into the function) moveStep() .(.) 的(The) moveStep() 功能将犯罪嫌疑人的图标沿着棋盘上的路径移动到板上(function moves the suspect’s icon over the board along the path which the) shortestPath() 计算并存储在全局函数中(function calculated and stored in the global) udrMoveAnimationInfo 结构变量,以图标从一个图块移动到另一个图块的任何方向,以每像素7个像素(每个图块的面积为28 x 28像素)的步长移动块,直到到达目的地.(structure variable, moving the piece along by steps of 7 pixels (each tile is 28 x 28 pixels in area) in whatever direction the icon is moving from one tile to the next, until it reaches its destination.) classSuspect 的位置用两个变量描述:(’s location is described with two variables:) eRoom 和(and) ptTile .自从(. Since the) eRoom 变量告诉程序该嫌疑人是(variable tells the program that that suspect is either)在一个房间里(in a room)(指定哪个房间),位于((specifies which room), at)起始位置(start-position), 要么(, or)在瓷砖上(on a tile),只有一次(, the only time the) ptTile 当犯罪嫌疑人的(variable is needed is when the suspect’s) eRoom 值设置为(value is set to) tiles .(.)

人工智能(Artificial Intelligence)

一旦使自己成为一个六人游戏的线索游戏(许多细节遗漏了),我便着手制作出我能想到的最聪明,最完美,才华横溢的人工智能.模拟此问题的最简单方法是计算每个嫌疑人玩的回合数,然后决定经过这么多回合后,这个或那个嫌疑人可能会"猜测"解决方案,并让其查看卡片.换句话说,作弊.(Once I had made myself a six-player game of clue (with many details left undone), I set out to make the smartest, perfectest, geniusistic artificial intelligence I could conjure. The simplest way to simulate this would be to count the number of turns each suspect plays, and then decide that after so many turns, there’s a chance that this or that suspect might ‘guess’ the solution and just have it look at the cards. In other words, cheat.) 但是那会带来什么乐趣呢？(But what would be the fun in that!?!) 不,那根本不是这样做的.天才设置充分利用了我提供的所有技巧.尽管我不是天才,但AI非常接近它.为了使我的计算机更加出色,我仔细记录了每个犯罪嫌疑人声明的卡(Nope, that’s not what this does at all. The genius setting takes advantage of every trick I’ve given it. And though I am no genius, the AI is pretty close to it. To geniusify my computer, I had it take careful notes of what cards each suspect declares they)没有(do not have),以及在显示卡牌时调用的每组卡牌.这样,在游戏的"证明建议"阶段的每个循环中,它可以检查以前的未知卡组是否包括最近宣布没有的任何嫌疑人卡,直到消除了这三张卡中的两张,然后确切知道显示了哪张卡转弯数,即使他们自己没有看到它.(, as well as each set of cards that were called when they did show a card. This way, at every cycle of the Prove Suggestion phase of the game, it can check if previous sets of unknown cards included a card any suspect recently declared not having, until it eliminates two of those three and then knows exactly what card was shown any number of turns ago, even though they didn’t see it themselves.) 例如:(For example:) 怀特夫人建议:(Mrs.White suggests :) 芥末上校(Col. Mustard)与(with)刀(Knife)在里面(in the)厨房(Kitchen).(.) 孔雀夫人说她没有卡.(and Mrs. Peacock says she has no card.) 但是以前,思嘉小姐建议(But previously, Miss Scarlet suggested) 芥末上校(Col. Mustard)与(with the)绳(rope)在里面(in the)厨房(kitchen).(.) 孔雀夫人转过身来,却向思嘉小姐出示了一张卡片.我们现在可以推断出的神秘卡片实际上是(and Mrs. Peacock, that turn, did show Miss Scarlet a card. A mystery card which we can now deduce was in fact the)绳(Rope)因为我们现在知道孔雀夫人没有(because we now know that Mrs. Peacock does not have)芥末上校(Col. Mustard)孔雀夫人没有(and Mrs. Peacock does not have the)厨房(Kitchen),因此她必须向史嘉蕾小姐展示了(, she must therefore have shown Miss Scarlet the)绳(Rope).(.) 跟随？(Follow?) 这位才华横溢的AI会记住所有未知的卡片,并会认真记下谁拒绝了什么卡片,这使得它很容易相对迅速地找出解决难题的方法.它还知道每个犯罪嫌疑人手中持有多少张牌(截至目前,在六人游戏中,每个犯罪嫌疑人手中持有三张牌),因此,一旦识别出这三张牌,天才AI就会知道那个犯罪嫌疑人确实没有其他卡片.为了解决这个难题,它可以消除列表中的每种可能性,或者可以注意到没有嫌疑人拥有该牌或那个牌,从而使该牌成为显而易见的选择.只要将嫌疑犯名单,武器清单和房间清单缩小到其中一个,它就会提出指控.而且,计算机永远不会出错(我没有费心把笨拙的级别弄错了,只是不那么努力).(The genius AI remembers all sets of unknown cards, and keeps diligent notes of who denied having what, making it fairly easy for it to figure out relatively quickly what the solution to the puzzle is. It also knows how many cards each suspect holds in their hand (as of now, in a six player game, each suspect holds three cards each), and so once those three cards have been identified, the genius-AI knows that that suspect does not have any other cards. To solve the puzzle, it can eliminate each possibility off of a list, or it can notice that no suspects have this or that card, making that one card the obvious choice. Whenever its list of suspects, list of weapons, and list of rooms is narrowed down to one of each, then it makes its accusation. And, the computer is never wrong (I didn’t bother making the dumber levels erroneous, just less diligent).) 但是,保持良好的表现并不是赢得一场好游戏的最终目标.(But keeping good notes isn’t the be-all and end-all of winning a good game of)线索(Clue).您仍然必须问正确的问题.(. You still have to ask the right questions.) classSuspect 在以下功能中执行此操作:(does this in the function below:)

public void makeSuggestion()
{
    prepareSuggestionAI();

    pickSuspectForSuggestion();
    pickWeaponForSuggestion();
    MainForm.udrSuggestion.eRoom = eRoom;
 ...

首先选择嫌疑犯,然后是武器.为了选择犯罪嫌疑人,它会翻阅其记录,试图消除"未知",这些是其他犯罪嫌疑人向第三方展示的卡片组.如果知道(by first picking a suspect, then a weapon. To make the selection of the suspect, it goes over its notes, trying to eliminate ‘unknowns’, those are the sets of cards which other suspects have shown to a third party. If it knows the)**WHO(Who)**在这个whodunit？中,那么它要么选择该卡,并确定它不会重新学习它已经知道的内容,要么可以选择手中持有的卡(我猜想如果计算机实际上有手).但是,在找出谁杀死了博迪先生之前,它必须通过研究"未知"来消除可能性.如果没有可疑类别的未知谜团,它会随机选择列表中剩余的所有可疑者.但是,如果确实要消除这些未知卡中的一个或多个,它将​​以相反的顺序绕过桌子,在该顺序中,建议将被拒绝,然后选择找到的第一张未知卡.它的顺序相反,因为这样的想法是最好在笔记本上收集尽可能多的X.如果您要求反驳建议的第一位嫌疑人向您显示一张卡片,则您将一个字段(可疑,武器或房间)缩小了一张卡片,但您还没有学到其他东西.通过将所有这些X收集在笔记本电脑上,可以更轻松地推断出显示给任何第三方的卡片,并且可以更快地解决难题.(in this whodunit?, then it may either choose that card, and be certain it doesn’t relearn what it already knows, or it may choose a card it holds in its hand (if a computer actually had hands, I guess). But before it can figure out who killed Mr. Boddy, it has to eliminate the possibilities by looking over the ‘unknowns’. If it has no mystery unknown for the suspect category, it just randomly picks any suspects remaining on its list. But if it does have one or more of these unknown suspect cards left to eliminate, it will go around the table in the reverse order in which the suggestion will be disproved, and then pick the first suspect-unknown-card it finds. It goes in the reverse order because the notion is that it’s best to collect as many Xs on your notebook as possible. If the first suspect you ask to disprove your suggestion shows you a card, you’ve narrowed one field (suspect, weapon, or room) by one card, but you haven’t learned much else. By collecting all these Xs on your notebook, it becomes much easier to deduce what cards are being shown to any third party, and the puzzle is solved much more quickly.) 然后,AI挑出一种建议武器,方法基本上是与挑出嫌疑犯一样,但是要记住,它不想询问神秘的未知武器卡,该卡片与嫌疑人列在同一列中.已选择的神秘未知嫌疑人卡.例如,如果知道Plum教授在被要求提供厨房,孔雀和烛台时出示了一张卡片,并且已经决定建议孔雀,那么它就不想建议烛台,因为如果消除了烛台,它已经解决了另一个.它可以通过询问不同的武器(不怀疑同一名嫌疑犯拥有的武器)来了解更多信息(原谅混乱).收集更多的X,解决更多的未知数,并减少更多的可能性,直到明确推断出谁,在哪里以及如何结束游戏为止.看到？简单.(Then the AI picks a weapon to suggest by essentially doing the same thing it did to pick a suspect, but keeping in mind that it doesn’t want to ask about a mystery unknown weapon-card which is in the same suspect-column as the mystery-unknown suspect card it has already picked. For example, if it knows Prof. Plum showed a card when he was asked for the Kitchen, Peacock, and Candlestick, and it has already decided to suggest Peacock, then it does not want to suggest Candlestick because if it eliminates one, it’s already resolved the other. It can learn more by asking about a different weapon, a weapon which it does not suspect the same suspect has (forgive the confusion). Collecting more Xs, resolving more unknowns, and reducing more possibilities, until a clear deduction of the who and the where and the how is made to end the game. See? Simple.) 麻利.(Quick and neat.) AI的内部记录保持定期使用两个重要功能:(The AI’s internal note keeping makes regular use of two important functions:)

void checkNote(enuCards eCard, enuSuspects eSuspect)

和(and)

public void XNote(enuCards eCard, enuSuspects eSuspect)

**笔记(Notes)**这里指的是内部代表用户在笔记本上以图形方式看到的内容的各个单元格(彩色正方形).每个可疑者(6)和每张卡片(21)都以二维阵列排列有6x21笔记.当推论或显示给定的嫌疑人有卡时,AI会检查它.(here refer to individual cells that represent internally what the user sees graphically on the notebook, the colored squares. There are 6x21 notes in a 2-dimensional array for each suspect (6) and each card (21). The AI checks a note whenever it has deduced or has been shown that a given suspect has a card.)

checkNote()(checkNote())

的(The) checkNote(eSuspect, eCard) 函数将数组中的特定注释设置为"检查",这意味着卡的持有人(function sets a specific note in the array to ‘check’, meaning that the holder of the card) eCard 被确定为嫌疑人(has been identified as the suspect) eSuspect ,并且如果已识别出持卡人,则已知所有其他嫌疑犯(, and if the holder of a card has been identified, then all the other suspects are known to)没有(not have)同一张卡片(每张卡片中只有一张),因此所有其他可疑者都对该X卡使用的特定卡片有记录(使用(the same card (there is only one of each card), and so all the other suspects have their note for that particular card X’ed (using) Xnote() 下面).同样,当确定了新卡的持有者后,便会进行一次已知嫌疑人卡的统计,如果所有嫌疑人的卡都已被识别,那么它就会知道该嫌疑人没有其他卡,因此所有其他卡片都已X’ed.(below). Also, when the holder of a new card has been identified, then a tally of cards which that suspect is known to have is made, and if all of that suspect’s cards have been identified, then it knows that that suspect has no other cards, so all other cards are X’ed.)

XNote()(XNote())

通过使用(X’ing a card by using the) XNote(eSuspect, eCard) 功能类似于(function is similar to) checkNote() 除了允许AI对犯罪嫌疑人的知识进行记录外(above, except that it lets the AI make a record of the knowledge that the suspect) eSuspect 不具有(does not have)卡片(the card) eCard .发生这种情况时,它将遍历所有神秘的未知卡片组,并寻找其中的一张卡片(. When this happens, it goes over all of its sets of mystery unknown cards and looks for one that includes the card) eCard 该嫌疑犯最近没有被发现,并消除了这些未知数.通过消除未知数,它可以将未知卡集中的卡数减少为一,然后进行检查(使用(which that suspect has recently been discovered not to have, and eliminates these unknowns. By eliminating unknowns, it can reduce the number of cards in unknown card-sets to one and can then check (using) checkNote() 上面)中的卡片.如果所有嫌疑人都知道(above) that card in its notes. If all suspects are known)不(not)拥有一张给定的卡片,则AI知道该卡片是解决方案的一部分,并相应地调整其建议.(to have a given card, then the AI knows that that card is part of the solution and adjusts its suggestion making accordingly.) 在X’ing和Check’ing(即Check’ing和X’ing)之间,X’ing和Check’ing很快就变成了很多形象,而且很快,整个混乱的谜团就很好地解开了.(Between X’ing and Check’ing, both Check’ing and X’ing, the X’ing and Check’ing soon cascades into a lot of figuring, and in no time, soon the whole muddled mystery unravels nicely.)

模仿天才AI(Dummifying the Geniustic AI)

放空!是的,你猜对了.如果桌子周围的所有嫌疑犯都是天才,那么尝试这款游戏很快就会感到沮丧.如果您要对抗一堆天才,要赢得比赛,需要运气(并且自动完成的帮助!).首先,天才们记住所有事情,从不犯错,并且非常记笔记游戏中发生的一切.您仍然可以调整建议,并很快找到答案,因为有很多方法可以击败它,但是…大多数人都喜欢与我们的普通人对抗.因此,这意味着AI有时需要有点愚蠢.幸运的是,这并不麻烦.从愚蠢到天才,共有五个级别的AI.为了使一台天才的计算机缩影,它所需要的只是一种讨厌的病毒,或者几行代码,涉及使用一种称为"随机数生成器"的东西.(Lobotomy! Yes, you guessed it. If all suspects around the table were geniuses, you would soon get frustrated trying to play this game. It takes luck (and untoggling of the Auto-Proceed helps!) in order to win a game if you’re playing against a bunch of geniuses. First of all, the geniuses remember everything, never make mistakes, and are very diligent in their note-taking about everything that happens in the game. You can still tweak your suggestion making and get to the answer pretty quick because there are ways to beat it, but … most people just like to play against us regular folk. So that means the AI needs to be a bit stupid sometimes. Luckily that’s not much of a bother. There are five levels of AI, ranging from Stupid-to-Genius. And to dummificate a geniustic computer, all it takes is a nasty virus, or a few lines of code that involve the use of something called a Random Number Generator.) 这是一个示例,其中AI决定是否要为该嫌疑人计算已识别卡的数量,然后如果AI已识别出该嫌疑人持有的所有卡,则X’化剩余的卡:(Here’s an example where the AI decides whether it wants to count the number of identified cards for this suspect and then X’ify the remaining cards if it has identified all of the cards which that suspect holds:)

// ai may notice that all of this suspect's cards have been identified
if ((eAILevel == enuAILevel.stupid && (int)(MainForm.rnd.NextDouble() * 1000) % 400 == 0)  
 || (eAILevel == enuAILevel.dull && (int)(MainForm.rnd.NextDouble() * 1000) % 50 == 0)
 || (eAILevel == enuAILevel.average && (int)(MainForm.rnd.NextDouble() * 1000) % 10 == 0)
 || (eAILevel == enuAILevel.bright && (int)(MainForm.rnd.NextDouble() * 1000) % 2 == 0)
 || (eAILevel == enuAILevel.genius ))
{
    int intCountNumCardsKnown = 0;
    for (enuCards eCardCounter = (enuCards)0; 
              eCardCounter < enuCards._numCards; eCardCounter++)
    {
        if (udrAILogic.eNotes[(int)eSuspect, (int)eCardCounter] == enuNote.check)
            intCountNumCardsKnown++;
    }
    if (intCountNumCardsKnown == MainForm.cSuspects[(int)eSuspect].cCards.Length)
    {
        // all of this suspect's cards have been identified
        //        -> X the ones that are unknown for this suspect
        for (enuCards eCardCounter = 
              (enuCards)0;eCardCounter < enuCards._numCards; eCardCounter++)
        {
            if (udrAILogic.eNotes[(int)eSuspect,(int)eCardCounter] != enuNote.check)
                XNote(eCardCounter, eSuspect);
        }
    }
}

图形和Hoopla(Graphics and the Hoopla)

您可能已经注意到了使这款游戏酷炫的漂亮效果.您以前看过的某些动画(如果您已阅读或下载了我以前的一些文章),如标题动画中的Jessica Rabbit.她使用了动画(You might have noticed the pretty effects which make this game kind of cool. Some of them you’ve seen before (if you’ve read or downloaded some of my previous articles) like Jessica Rabbit in the title animation. She’s animated using) classSprite 我在上一篇文章中讨论过:(which I discussed in a previous article:) .NET的Sprite编辑器(Sprite Editor for .NET) .对于使用过此类的任何人,您将很高兴知道我已经做了一些升级,其中最重要的是加快了加载时间.该类的主要缺点是加载时间很长,使用起来很繁琐.但是此新升级向后兼容,并且会自动从以下版本升级Sprite文件:(. For anyone who has made use of this class, you will be glad to know that I’ve made a few upgrades, the most important of which is the accelerated load time. The major draw-back of the class was that it took so long to load it became tedious to use. But this new upgrade is backwardly compatible, and automatically upgrades the sprite files from).spr(.spr)至(to).sp2(.sp2),这样可以将加载时间减少10倍(至少!).只需下载此线索代码,然后复制(, so that it will reduce the load time by a factor of 10 (at least!). Just download this Clue code, copy) classSprite 从它,并贴在任何地方.(from it, and stick it wherever.) 至于其他漂亮的东西,没有比杰西卡辛普森(Jessica Simpson)还要漂亮的东西.呃...呃...原谅弗洛里安(我自己是Ashlee粉丝!),没有什么比杰西卡兔子(Jessica Rabbit)更漂亮了,卡本身也很酷.就像我之前提到的,该项目中的所有图像都是从Internet下载并进行修改的.当我决定要动画处理卡片分类,改组三种不同类型以及在处理剩余卡片之前选择神秘卡片的过程时,我必须为每张卡片生成"精灵".这似乎不必要,所以我创建了一个新类型(As for the other pretty things, there isn’t anything quite as pretty as Jessica Simpson. Er… uhh… forgive the freudian (I’m an Ashlee fan myself!), there isn’t anything quite as pretty as Jessica Rabbit, the cards themselves are kinda cool. Like I mentioned earlier, all the images in this project were downloaded off the internet and modified. And when I decided I wanted to animate the process of sorting the cards, shuffling the three different types, and picking the mystery cards before dealing the remaining ones, I had to generate ‘sprites’ for each card. This seemed unnecessary, so I created a new type called) classRotatedImage .此类会获取输入图像,将其旋转3次,然后将四个基本图像存储在(. This class takes an input image, rotates it three times, and stores four base images in an)**.rbmp(.rbmp)**文件放在硬盘上.这样做需要时间,这就是为什么第一次加载游戏要花大约两分钟的时间才能看到简介动画,但是一旦生成了这些卡,加载时间就会快得多.这四个基本图像在零和pi/2弧度(或其附近)之间均匀地旋转,因此.NET的本机图像(file on the hard-drive. Doing this takes time, and that is the reason why the first time you load the game, it will take up to two minutes before you can see the intro-animation, but once these cards are generated, the load time is much much faster. These four base-images are rotated evenly between zero and pi/2 radians (or thereabouts) so that .NET’s native) Bitmap 的(’s) FlipRotate 然后可以使用函数生成该类特定实例的总共16张旋转图像中的其余12张.(function can then be used to generate the remaining 12 of the total rotated 16 images of that particular instance of the class.)

不要翻转(Don’t flip out)

这个项目最困难的部分是在发牌动画过程中让卡片翻转.这是将卡片分类并然后面朝上散开的部分.这个想法的目的是创造一种效果,使两张二维图像在一系列纸牌中翻转时产生错觉,就像魔术师可以通过将纸牌摊开到桌子上,然后翻转第一张纸牌并观察其余的跟随.创建翻页式错觉只是在动画过程中将图像缩小到适当的大小,然后将其扩大到反面再次变为正常大小即可.但是要同时获得一堆纸牌要困难一点,它是通过以下主要形式完成的:(The single most difficult part of this project was getting the cards to flip during the deal-cards animation. This is the part where the cards have been sorted into categories then spread out face-up. The idea was to create an effect that would give the illusion of these two dimensional images flipping in a cascade of cards, much like a magician might by spreading the cards out onto the table and then flip the first card and watch the rest of them follow. Creating the flip-one-card illusion is just a matter of slimming the image to an appropriate size during the animation, then widening it until it is normal size again on the reverse side. But getting a cascade of cards to do that at the same time was a bit more difficult, and it was done in the main form’s:)

AnimateDealCards_FlipCardsUtoD_DirR(enuCardType eTypeCard)

函数,其调用方式为:(function, which is called by:)

animateDealCards()

当…的时候(When the) tmrDelay 的滴答事件处理程序跳闸,(’s tick event handler trips,) eMode 在(is in) dealCards 模式和变量(mode, and the variable) eDealMode 设定为(is set to) flipWeaponcards ,(,) flipSuspectcards , 要么(, or) flipRoomcards .(.) 这个想法是要模拟魔术师将一堆纸牌摊开放在桌子上,然后翻转第一张纸牌并看着其余的纸牌翻转之后的动作.为此,该程序将卡片散开并保留在桌子上的位置.然后,它在整个传播范围内移动一个看不见的手指.每张卡的边缘都与桌子保持接触.该边缘与桌子接触的点称为该卡的枢轴点.在翻页动画期间的任何情况下,仍将其枢轴点保持在不可见手指的右侧的最​​左边的卡被指定为枢轴卡.这是左侧最靠前的一张,仍朝上.首先绘制它,然后在其右边绘制下一个,再在其后绘制,依此类推,直到绘制了右边的最后一张卡片,然后动画继续将卡片绘制到枢轴点左侧另一种是从距离枢纽卡最近的卡开始,直到完成到价差左侧最远的卡为止.(The idea was to simulate something like what a magician might do when he spreads a pack of cards out onto the table, then flips the first one and watches the rest of them flip after it. To do this, the program spreads the cards out and retains their locations on the table. Then it moves an invisible finger across the breadth of the entire spread. Each card has one edge which remains in contact with the table; the point at which this edge makes contact with the table is called that card’s pivot-point. The left-most card that still has its pivot point to the right of the invisible finger is designated the pivot-card at any instance during the card-flip animation. This is the furthest card to the left that is still face-up. It is drawn first, then the next one to its right, then the one after, and so on until the last card to the right has been drawn, and the animation then proceeds to draw the cards to the left of the pivot point one after another, starting from the card nearest to the pivot card until it finishes with the card furthest to the left of the spread.) 但是在绘制任何这些卡之前,需要计算它们的相对图像宽度.为此,该算法将循环执行,同时从侧面查看卡片.(But before drawing any of these cards, their relative image widths need to be calculated. To do this, the algorithm loops while looking at the cards from a side view.)

要计算卡B的宽度,它是:(To calculate the width of card B, it:)

• 知道卡片A的浮动边(x,y)在上面的位置(knows the location of card A’s floating edge (x, y) above)
• 卡A的枢轴点和卡B的枢轴点之间的距离(the distance between card A’s pivot point and card B’s pivot point)
• 计算卡A和B之间的接触点(it calculates the contact point between cards A and B)
• 然后计算出B卡与桌子的夹角(it then calculates the angle card B makes with the table)
• 然后知道卡片B的输出图像的所需宽度(and then knows the desired width of the output image of card B) 由于此算法将一张卡的接触点用作下一张卡的计算的"浮动边",因此它可以轻松地在所有卡之间依次循环.每张面朝下的卡片(位于枢轴卡片左侧的卡片)的大小都以相同的方式计算,但相反,x值取反以简化操作.但是,紧靠枢轴卡左侧的卡可以将其边缘压在枢轴卡的侧面,也可以将其侧面压在枢轴卡的边缘,并且在翻转一周之后(以一种非常冷静,镇定和有尊严的方式),我决定通过将两个浮动边的X值都设置为不可见手指的位置来近似该效果就足够了(这不是加热的指导系统-寻找导弹,毕竟).到此为止.(Since the contact point of one card is used in the next’s card’s calculations as the ‘floating edge’ by this algorithm, it can easily cycle through all the cards one after the other. The sizes of each of the face-down cards (those to the left of the pivot card) are calculated in much the same way, but in reverse, with negated x values to simplify things. However, the card immediately to the left of the pivot card can either have its edge pressed against the side of the pivot card, or it can have its side pressed against the edge of the pivot card and, after a week of flipping out about this (in a very cool, calm, and dignified manner), I decided that approximating this by setting both of their floating edge’s X values to the invisible finger’s position was going to be just good enough (this isn’t the guidance system of a heat-seeking missile, after all). And that was the end of that.)

窥镜背后(Behind the Looking Glass)

动画简介非常酷.是的,非常酷.(The intro-animation is pretty cool. Yep, pretty cool.) 为此,我使用了放大了三倍的板子和笔记本的副本,并将其保存在内存中.该图像太大,无法流畅地运行动画,因此将其切成更小的图像阵列,并将整个地图内容存储在此阵列中,所使用的内存大约是该图像的两倍.以前,但是每个较小的图像都可以通过将放大镜及其后面的放大图像绘制到屏幕上的算法更轻松地访问和使用.这些小包的整体宽度是通过计算最小值确定大小的,该最小值均匀地分为整个放大图像的宽度,并且也大于放大镜透镜宽度的两倍.高度以类似的方式完成.(To do this, I used a copy of the board and notebook magnified by a factor of three, and kept it in memory. This image is much too large to run the animation smoothly, so it is then cut up into an array of much smaller images, and the whole bit-of-the-map thing is stored in this array, using about twice as much memory than before, but each smaller image can be accessed and used much more easily by the algorithm that draws the magnifying glass and the magnified image behind it onto the screen. The width of these parcels of the whole are sized by calculating the smallest value, which divides evenly into the width of the entire magnified image, and is also bigger than twice the width of the magnifying glass’ lens. The height is done in a similar fashion.)

放大镜镜头图像包括(The magnifying glass lens image consists of)

• 镜头的边缘(the rim of the lens,)
• 镜片边缘周围的红色区域(a red-colored area around the rim of the lens)
• 镜头内部有白色区域(and a white colored area inside the lens) 这个放大镜在(This magnifying glass is moved around the)放大图像(magnified image).确定其位置后,移动后将对其表面积进行描述(镜头的实际位置作为镜头中心的位置存储在内存中,因此需要计算镜头覆盖的面积).然后将该表面区域从存储在上一段中所述区域的一个宗地图像中复制到镜头大小的新位图上.将镜头边缘内的区域设为透明,然后将镜头叠加到刚刚创建的放大板的新位图上,以使放大图像看起来像是在"镜头后面".然后,将镜头边缘周围的红色区域设为透明,然后将新的图像,边缘和镜头后面的放大游戏板绘制到板子和笔记本的常规尺寸副本上,然后转到屏幕.(. When its location is determined, after it has been moved, its surface area is described (the actual position of the lens is stored in memory as the position of the center of the lens, so that the area which the lens covers needs to be calculated). This surface area is then copied from one of the parcel images, stored in the area described in the previous paragraph, onto a new bitmap the size of the lens. The area inside the lens’s rim is made transparent, and then the lens is superimposed onto the new bitmap of the magnified board we’ve just created so as to make the magnified image appear as if it were “behind the lens”. Then the red area around the rim of the lens is made transparent, and this new image, rim, and magnified game-board behind the lens are drawn onto a regular sized copy of the board and notebook before going to the screen.) 那就是如果没有任何抗议的老鼠和蜘蛛网.沃尔多兄弟在这里做什么呢？但是,事情总是可以改善的,因此,这就是为什么我们需要添加一些动画的原因.动画角色全部使用新的(And that would be that if there weren’t any protesting rats and spider-webs. And what’s this Waldo dude doing here anyway? But then things can always be improved, and so, that is the reason why we need to throw in a bit of animation. The animated characters are all done using the new) classSprite ,不管别人是否在看着他们(他们各自(, and they do their thing whether or not anyone is watching them (their respective) intConfiguration 和(and) intConfigurationStep 简介动画的每次迭代都会更新这些值).每当放大镜足够接近需要它们时,它们的图像就会生成并显示在屏幕上.在绘制放大镜镜头之前,将这些子画面图像放置在大型板图像的副本上,然后将其放置在常规尺寸板的位图上.(values are updated at each iteration of the intro animation). Their images are generated and put to the screen whenever the magnifying glass comes close enough for them to be needed. These sprite images are placed onto the copy of the mega-board images before the magnifying glass' lens is drawn and then placed onto a bitmap of the regular sized board.) 完成所有这些操作后,将放大镜的手柄绘制到屏幕上,整个动画将一直循环播放,直到用户开始新游戏为止.(When all that is done, the magnifying glass' handle is drawn onto the screen, and the whole animation just loops until the user begins a new game.)

提出被告(Bring Forward the Accused)

当用户(或智能化,愚蠢或愚蠢的计算机AI)最终提出指控时,我们将自己推向了(When the user (or the computer AI geniusified, dullified, or stupidated) finally makes an accusation, we roll ourselves into the)**我指责(I accuse)**事物的模式.这是一些简洁的代码,它可以创造出相当酷的效果.一切都有两张图像:一张为彩色,另一张为黑白.除了泛光灯之外,活动部件都在前景中,背景不过是背景.但是,黑白背景确实有一个彩色的"我指控",指控嫌疑犯和讲话泡沫,但除此之外,其他所有事物都是黑白的.(mode of things. This is a bit of neat code in that it creates a reasonably cool effect. There are two images of everything: one in color and another in black/white. The moving parts, aside from the floodlight, are in the foreground, and the background is nothing but background. The black/white background, however, does have a colored “I accuse” accusing suspect and speaking bubble, but aside from that, everything else is in black and white.)

使用蓝屏(我不在绿屏上,我从门外的绿色和平那里发了愤怒的捡拾器,我担心他们会做什么),我通过画一个"泛光灯"来移动在我的蓝色屏幕上的透明圆圈上,然后将其叠加到彩色图像上(将动画彩色前景绘制到彩色背景上),并切出该图像的彩色圆形部分;然后,使生成的图像的蓝色部分透明,将其绘制到黑白图像上,并通过移动泛光灯重复该过程,直到我们终于准备好翻转卡片并查看"谁和怎么做"!(Using a blue-screen (I’m off the green screen, I got angry picketers from Green-Peace outside my door, and I’m afraid what they’re going to do), I move my ‘floodlight’ around by drawing a transparent circle on my blue screen, and then superimpose this onto the colored image (with the animated colored foreground drawn onto the colored background), and cut-out a colored circular segment of that image; then, making the blue part of the resultant image transparent, I draw this onto the black/white image, and repeat the process by moving the floodlight around until we’re finally ready to flip the cards and see the Who and How!) 但是可悲的是,我们可能永远不知道为什么博迪先生如此惨烈地被谋杀.(But sadly, we may never know why Mr. Boddy was murdered so tragically.)

许可

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