msgid ""
msgstr "Content-Type: text/plain; charset=UTF-8"
#: tform1.btnok.caption
msgctxt "tform1.btnok.caption"
msgid "OK"
msgstr "确定"

#: tform1.button1.caption
msgctxt "tform1.button1.caption"
msgid "Next"
msgstr "下一步"

#: tform1.button1.hint
msgid "Click this to continue!!!"
msgstr "点击此处继续！！！"

#: tform1.caption
msgid "Cheat Engine Tutorial v3.4"
msgstr "Cheat Engine 教程 v3.4"

#: tform1.edtpassword.hint
msgid "Use this to go imeadiatly to the step you want to try"
msgstr "使用此功能直接跳转到您想尝试的步骤"

#: tform1.edtpassword.text
msgid "090453"
msgstr "090453"

#: tform1.label1.caption
msgid "Password"
msgstr "密码"

#: tform10.button3.caption
msgid "Restart game"
msgstr "重新开始游戏"

#: tform10.button4.caption
msgctxt "tform10.button4.caption"
msgid "Attack"
msgstr "攻击"

#: tform10.button5.caption
msgctxt "tform10.button5.caption"
msgid "Attack"
msgstr "攻击"

#: tform10.button6.caption
msgctxt "tform10.button6.caption"
msgid "Restart game and autoplay"
msgstr "重新开始游戏并自动播放"

#: tform10.button7.caption
msgctxt "tform10.button7.caption"
msgid "Attack"
msgstr "攻击"

#: tform10.button8.caption
msgctxt "tform10.button8.caption"
msgid "Attack"
msgstr "攻击"

#: tform10.caption
msgid "Step 9"
msgstr "步骤 9"

#: tform10.label1.caption
msgctxt "tform10.label1.caption"
msgid "100"
msgstr "100"

#: tform10.label10.caption
msgctxt "tform10.label10.caption"
msgid "Health: 500"
msgstr "生命值：500"

#: tform10.label2.caption
msgctxt "tform10.label2.caption"
msgid "Health:"
msgstr "生命值："

#: tform10.label3.caption
msgid "Player 1: Dave"
msgstr "玩家 1：Dave"

#: tform10.label4.caption
msgctxt "tform10.label4.caption"
msgid "Health: 100"
msgstr "生命值：100"

#: tform10.label5.caption
msgid "Player 2: Eric"
msgstr "玩家 2：Eric"

#: tform10.label6.caption
msgctxt "tform10.label6.caption"
msgid "Health: 100"
msgstr "生命值：100"

#: tform10.label7.caption
msgid "C. Player 3: HAL"
msgstr "电脑玩家 3：HAL"

#: tform10.label8.caption
msgctxt "tform10.label8.caption"
msgid "Health: 500"
msgstr "生命值：500"

#: tform10.label9.caption
msgid "C. Player 4: KITT"
msgstr "电脑玩家 4：KITT"

#: tform2.button1.caption
msgctxt "tform2.button1.caption"
msgid "Next"
msgstr "下一步"

#: tform2.button2.caption
msgctxt "tform2.button2.caption"
msgid "Hit me"
msgstr "点击我"

#: tform2.caption
msgid "Step 2"
msgstr "步骤 2"

#: tform2.label1.caption
msgctxt "tform2.label1.caption"
msgid "100"
msgstr "100"

#: tform2.label2.caption
msgctxt "tform2.label2.caption"
msgid "Health:"
msgstr "生命值："

#: tform2.speedbutton1.caption
msgctxt "tform2.speedbutton1.caption"
msgid "Skip"
msgstr "跳过"

#: tform3.button1.caption
msgctxt "tform3.button1.caption"
msgid "Next"
msgstr "下一步"

#: tform3.button2.caption
msgctxt "tform3.button2.caption"
msgid "Hit me"
msgstr "点击我"

#: tform3.caption
msgid "Step 3"
msgstr "步骤 3"

#: tform3.label1.caption
msgid " "
msgstr " "

#: tform3.speedbutton1.caption
msgctxt "tform3.speedbutton1.caption"
msgid "Skip"
msgstr "跳过"

#: tform4.button1.caption
msgctxt "tform4.button1.caption"
msgid "OK"
msgstr "确定"

#: tform4.caption
msgid "Tutorial End"
msgstr "教程结束"

#: tform4.label1.caption
msgid "Well done, you've completed the tutorial of Cheat Engine."
msgstr "干得不错，你已经完成了 Cheat Engine 的教程。"

#: tform4.label2.caption
msgid "Just play around with the tutorial and learn how the other scanmethods work."
msgstr "继续使用教程，学习其他扫描方法的工作原理。"

#: tform4.label3.caption
msgid "And you can always check out the Cheat Engine Forum for useful information and ask for help"
msgstr "你还可以随时访问 Cheat Engine 论坛获取有用信息并寻求帮助"

#: tform4.label4.caption
msgid "Cheat Engine Forum"
msgstr "Cheat Engine 论坛"

#: tform5.button1.caption
msgid "Fire"
msgstr "开火"

#: tform5.button2.caption
msgctxt "tform5.button2.caption"
msgid "Next"
msgstr "下一步"

#: tform5.button3.caption
msgctxt "tform5.button3.caption"
msgid "Hit me"
msgstr "点击我"

#: tform5.caption
msgid "Step 4"
msgstr "步骤 4"

#: tform5.label1.caption
msgctxt "tform5.label1.caption"
msgid "100"
msgstr "100"

#: tform5.label2.caption
msgid "Ammo"
msgstr "弹药"

#: tform5.label3.caption
msgctxt "tform5.label3.caption"
msgid "Health:"
msgstr "生命值："

#: tform5.label4.caption
msgctxt "tform5.label4.caption"
msgid "100"
msgstr "100"

#: tform5.label5.caption
msgid "(float)"
msgstr "(浮点数)"

#: tform5.label6.caption
msgid "(double)"
msgstr "(双精度)"

#: tform5.speedbutton1.caption
msgctxt "tform5.speedbutton1.caption"
msgid "Skip"
msgstr "跳过"

#: tform6.button1.caption
msgctxt "tform6.button1.caption"
msgid "Change value"
msgstr "更改值"

#: tform6.button2.caption
msgctxt "tform6.button2.caption"
msgid "Next"
msgstr "下一步"

#: tform6.caption
msgid "Step 5"
msgstr "步骤 5"

#: tform6.label1.caption
msgctxt "tform6.label1.caption"
msgid "100"
msgstr "100"

#: tform6.speedbutton1.caption
msgctxt "tform6.speedbutton1.caption"
msgid "Skip"
msgstr "跳过"

#: tform7.button1.caption
msgctxt "tform7.button1.caption"
msgid "Change value"
msgstr "更改值"

#: tform7.button2.caption
msgctxt "tform7.button2.caption"
msgid "Next"
msgstr "下一步"

#: tform7.button3.caption
msgctxt "tform7.button3.caption"
msgid "Change pointer"
msgstr "更改指针"

#: tform7.caption
msgid "Step 6"
msgstr "步骤 6"

#: tform7.label1.caption
msgctxt "tform7.label1.caption"
msgid "100"
msgstr "100"

#: tform7.label2.caption
msgctxt "tform7.label2.caption"
msgid "3"
msgstr "3"

#: tform7.speedbutton1.caption
msgctxt "tform7.speedbutton1.caption"
msgid "Skip"
msgstr "跳过"

#: tform8.button1.caption
msgctxt "tform8.button1.caption"
msgid "Hit me"
msgstr "点击我"

#: tform8.button2.caption
msgctxt "tform8.button2.caption"
msgid "Next"
msgstr "下一步"

#: tform8.caption
msgid "Step 7"
msgstr "步骤 7"

#: tform8.label1.caption
msgctxt "tform8.label1.caption"
msgid "Health: 100"
msgstr "生命值：100"

#: tform8.speedbutton1.caption
msgctxt "tform8.speedbutton1.caption"
msgid "Skip"
msgstr "跳过"

#: tform9.button1.caption
msgctxt "tform9.button1.caption"
msgid "Change value"
msgstr "更改值"

#: tform9.button2.caption
msgctxt "tform9.button2.caption"
msgid "Next"
msgstr "下一步"

#: tform9.button3.caption
msgctxt "tform9.button3.caption"
msgid "Change pointer"
msgstr "更改指针"

#: tform9.caption
msgid "Step 8"
msgstr "步骤 8"

#: tform9.label1.caption
msgctxt "tform9.label1.caption"
msgid "100"
msgstr "100"

#: tform9.label2.caption
msgctxt "tform9.label2.caption"
msgid "3"
msgstr "3"

#: tform9.speedbutton1.caption
msgctxt "tform9.speedbutton1.caption"
msgid "Skip"
msgstr "跳过"

#: tfrmhelp.caption
msgid "Help"
msgstr "帮助"

#: tfrmhelp.image1.hint
msgid "More information like videos for this step and written tutorials"
msgstr "有关此步骤的更多信息，例如视频和书面教程"

#: unit1.rsfirststeptoohardbettergiveupnow
msgid "First step too hard? Go to forum.cheatengine.org, then click on \"Tutorials\" for helpful guides!"
msgstr "第一步太难了？前往 forum.cheatengine.org，然后点击“教程”获取有用的指南！"

#: unit1.rstutorial1
msgid ""
"Welcome to the Cheat Engine Tutorial (v3.6)\n"
"\n"
"This tutorial will teach you the basics of cheating in video games. It will also show you foundational aspects of using Cheat Engine (or CE for short). Follow the steps below to get started.\n"
"\n"
"1: Open Cheat Engine if it currently isn't running.\n"
"2: Click on the \"Open Process\" icon (it's the top-left icon with the computer on it, below \"File\".).\n"
"3: With the Process List window now open, look for this tutorial's process in the list. It will look something like \"00001F98-Tutorial-x86_64.exe\" or \"0000047C-Tutorial-i386.exe\". (The first 8 numbers/letters will probably be different.)\n"
"4: Once you've found the process, click on it to select it, then click the \"Open\" button. (Don't worry about all the other buttons right now. You can learn about them later if you're interested.)\n"
"\n"
"Congratulations! If you did everything correctly, the process window should be gone with Cheat Engine now attached to the tutorial (you will see the process name towards the top-center of CE).\n"
"\n"
"Click the \"Next\" button below to continue, or fill in the password and click the \"OK\" button to proceed to that step.)\n"
"\n"
"If you're having problems, simply head over to forum.cheatengine.org, then click on \"Tutorials\" to view beginner-friendly guides!"
msgstr ""
"欢迎来到 Cheat Engine 教程（v3.6）\n"
"\n"
"本教程将教你如何在视频游戏中作弊的基础知识，并向你展示如何使用 Cheat Engine（简称 CE）。请按照以下步骤开始。\n"
"\n"
"1: 如果 Cheat Engine 尚未运行，请打开它。\n"
"2: 点击“打开进程”图标（这是位于“文件”下方的左上角图标，上面有一个电脑图案）。\n"
"3: 打开进程列表窗口后，在列表中查找本教程的进程。它看起来会像“00001F98-Tutorial-x86_64.exe”或“0000047C-Tutorial-i386.exe”。（前 8 位数字/字母可能会有所不同。）\n"
"4: 找到进程后，点击它以选择它，然后点击“打开”按钮。（暂时不用担心其他按钮，如果你感兴趣，稍后可以了解它们的功能。）\n"
"\n"
"恭喜！如果你按照上述步骤正确操作，进程窗口应该已经消失，Cheat Engine 现在已经连接到教程（你可以在 CE 的顶部中间看到进程名称）。\n"
"\n"
"点击下面的“下一步”按钮继续，或者填写密码并点击“确定”按钮直接跳转到该步骤。\n"
"\n"
"如果你遇到问题，可以直接前往 forum.cheatengine.org，然后点击“教程”查看适合初学者的指南！"

#: unit10.rsdead
msgid "DEAD"
msgstr "已死亡"

#: unit10.rsfailureyourteamdied
msgid "Failure. Your team died"
msgstr "失败。你的队伍已经死亡"

#: unit10.rshealth
#, object-pascal-format
msgid "Health: %s"
msgstr "生命值：%s"

#: unit10.rsrestartgameandautoplay
msgctxt "unit10.rsrestartgameandautoplay"
msgid "Restart game and autoplay"
msgstr "重新开始游戏并自动播放"
#: unit10.rsstep9sharedcodepw
#, object-pascal-format
msgid "Step 9: Shared code: (PW=%s)"
msgstr "步骤 9：共享代码：(密码=%s)"

#: unit10.rsstop
msgid "Stop"
msgstr "停止"

#: unit10.rsthisplayerisalreadydeadrestartthegame
msgid "This player is already dead. Restart the game"
msgstr "该玩家已经死亡。请重新开始游戏"

#: unit10.rstryagain10
msgid "Can't figure out how to do this? Don't worry. Try asking in the forum at cheatengine.org or perhaps someone already explained it better there. Are you sure you want to quit?"
msgstr "不知道怎么做？别担心。可以去 cheatengine.org 的论坛问问，也许那里已经有人更好地解释过了。你确定要退出吗？"

#: unit10.rstutorialstep9
msgid ""
"This step will explain how to deal with code that is used for other object of the same type\n"
"\n"
"Often when you've found health of a unit or your own player, you will find that if you remove the code, it affects enemies as well.\n"
"In these cases you must find out how to distinguish between your and the enemies objects.\n"
"Sometimes this is as easy as checking the first 4 bytes (Function pointer table) which often point to a unique location for the player, and sometimes it's a team number, or a pointer to a pointer to a pointer to a pointer to a pointer to a playername. It all depends on the complexity of the game, and your luck\n"
"\n"
"The easiest method is finding what addresses the code you found writes to and then use the dissect data feature to compare against two structures. (Your unit(s)/player and the enemies) And then see if you can find out a way to distinguish between them.\n"
"When you have found out how to distinguish between you and the computer you can inject an assembler script that checks for the condition and then either do not execute the code or do something else. (One hit kills for example)\n"
"Alternatively, you can also use this to build a so called \"Array of byte\" string which you can use to search which will result in a list of all your or the enemies players\n"
"In this tutorial I have implemented the most amazing game you will ever play.\n"
"It has 4 players. 2 Players belong to your team, and 2 Players belong to the computer. \n"
"Your task is to find the code that writes the health and make it so you win the game WITHOUT freezing your health\n"
"To continue, press \"Restart game and autoplay\" to test that your code is correct\n"
"\n"
"\n"
"Tip: Health is a float\n"
"Tip2: There are multiple solutions"
msgstr ""
"本步骤将解释如何处理用于同一类型其他对象的代码\n"
"\n"
"当你找到单位或自己的生命值代码时，通常会发现，如果移除该代码，敌人的生命值也会受到影响。\n"
"在这种情况下，你需要找出如何区分自己和敌人的对象。\n"
"有时，这可能像检查前 4 个字节（函数指针表）一样简单，这通常会指向玩家的唯一位置，有时可能是队伍编号，或者是指向玩家名称的多级指针。这完全取决于游戏的复杂性和你的运气。\n"
"\n"
"最简单的方法是找出你找到的代码写入的地址，然后使用数据分解功能与两个结构进行比较（你的单位/玩家和敌人），看看是否可以找到区分它们的方法。\n"
"当你找到区分自己和电脑的方法后，可以注入一个汇编脚本，检查条件，然后选择不执行代码或执行其他操作（例如一击必杀）。\n"
"或者，你也可以利用这一点构建一个所谓的“字节数组”字符串，用于搜索，结果将列出所有你或敌人的玩家。\n"
"在本教程中，我实现了一个你将玩到的最令人惊叹的游戏。\n"
"它有 4 名玩家。2 名玩家属于你的队伍，2 名玩家属于电脑。\n"
"你的任务是找到写入生命值的代码，并确保你在不冻结生命值的情况下赢得游戏。\n"
"要继续，请按“重新开始游戏并自动播放”，以测试你的代码是否正确。\n"
"\n"
"\n"
"提示：生命值是一个浮点数\n"
"提示 2：有多种解决方案"

#: unit10.rsu10thiswasthelasttutorial
msgid "This was the last tutorial and you skipped it. You lose"
msgstr "这是最后一个教程，你跳过了它。你输了"

#: unit2.rsawyouredeathletmereviveyou
msgctxt "unit2.rsawyouredeathletmereviveyou"
msgid "Aw, you're dead! Let me revive you"
msgstr "哎呀，你死了！让我帮你复活"

#: unit2.rsloser
msgctxt "unit2.rsloser"
msgid "BOO"
msgstr "失败！"

#: unit2.rsquittingonstep2thisistheeasieststepthereisfindheal
msgid "Quitting on step2? This is the easiest step there is. Find health, change health, done.... Sure you want to quit?"
msgstr "要在第 2 步就放弃吗？这是最简单的一步。找到生命值，修改生命值，就完成了……你确定要退出吗？"

#: unit2.rsstep2exactvaluescanningpw
msgid "Step 2: Exact Value scanning (PW="
msgstr "步骤 2：精确值扫描（密码="

#: unit2.rstutorialstep2
msgid ""
"Now that you have opened the tutorial with Cheat Engine let's get on with the next step.\n"
"\n"
"You can see at the bottom of this window is the text Health: xxx\n"
"Each time you click 'Hit me'  your health gets decreased.\n"
"\n"
"To get to the next step you have to find this value and change it to 1000\n"
"\n"
"To find the value there are different ways, but I'll tell you about the easiest, 'Exact Value':\n"
"First make sure value type is set to at least 2-bytes or 4-bytes. 1-byte will also work, but you'll run into an easy to fix problem when you've found the address and want to change it. The 8-byte may perhaps works if the bytes after the address are 0, but I wouldn't take the bet.\n"
"Single, double, and the other scans just don't work, because they store the value in a different way.\n"
"\n"
"When the value type is set correctly, make sure the scantype is set to 'Exact Value'\n"
"Then fill in the number your health is in the value box. And click 'First Scan'\n"
"After a while (if you have an extremely slow pc) the scan is done and the results are shown in the list on the left.\n"
"\n"
"If you find more than 1 address and you don't know for sure which address it is, click 'Hit me', fill in the new health value into the value box, and click 'Next Scan'\n"
"repeat this until you're sure you've found it. (that includes that there's only 1 address in the list.....)\n"
"\n"
"Now double click the address in the list on the left. This makes the address pop-up in the list at the bottom, showing you the current value.\n"
"Double click the value, (or select it and press enter), and change the value to 1000.\n"
"\n"
"If everything went ok the Next button should become enabled, and you're ready for the next step.\n"
"\n"
"\n"
"Note:\n"
"If you did anything wrong while scanning, click \"New Scan\" and repeat the scanning again.\n"
"Also, try playing around with the value and click 'Hit me'."
msgstr ""
"现在你已经用 Cheat Engine 打开了教程，让我们继续下一步。\n"
"\n"
"你可以看到在这个窗口底部显示着“生命值：xxx”。\n"
"每次点击“点击我”，你的生命值就会减少。\n"
"\n"
"要进入下一步，你需要找到这个值并将其修改为 1000。\n"
"\n"
"找到这个值有多种方法，但我来告诉你最简单的一种：“精确值”。\n"
"首先确保值类型设置为至少 2 字节或 4 字节。1 字节也可以，但当你找到地址并尝试修改它时，可能会遇到一个很容易解决的问题。如果地址后面的字节是 0，8 字节可能也能工作，但我不会冒险。\n"
"单精度、双精度和其他扫描方式都不行，因为它们以不同的方式存储值。\n"
"\n"
"当值类型设置正确后，确保扫描类型设置为“精确值”。\n"
"然后在值框中输入你的生命值，并点击“首次扫描”。\n"
"过一会儿（如果你的电脑非常慢），扫描就会完成，结果会显示在左侧的列表中。\n"
"\n"
"如果你找到了多个地址，不确定哪个是正确的，点击“点击我”，将新的生命值输入到值框中，然后点击“下一次扫描”。\n"
"重复这个过程，直到你确定找到了正确的地址。（也就是说，列表中只剩下一个地址了）。\n"
"\n"
"现在双击左侧列表中的地址。这会使地址出现在底部的列表中，显示当前的值。\n"
"双击该值（或者选中它并按回车键），并将值修改为 1000。\n"
"\n"
"如果一切顺利，“下一步”按钮应该会启用，你就可以继续下一步了。\n"
"\n"
"\n"
"注意：\n"
"如果你在扫描过程中做错了什么，点击“新扫描”并重新开始扫描。\n"
"此外，尝试调整值并点击“点击我”。"

#: unit3.rsdead
msgid "Seems you've done it again! Let me get a replacement! (And restart your scan!)"
msgstr "看来你又死了！让我帮你重新开始！（并重新开始扫描！）"

#: unit3.rsloser
msgctxt "unit3.rsloser"
msgid "BOO"
msgstr "失败！"

#: unit3.rsstep3unknowninitialvaluepw
msgid "Step 3: Unknown initial value (PW="
msgstr "步骤 3：未知初始值（密码="

#: unit3.rstryagain3
msgid "Step 3 isn't really that hard. Just do a new scan, unknown initial value and then decreased value till you find it. Almost everyone gets past this one. Sure you want to quit?"
msgstr "步骤 3 其实并不难。只需要进行一次新的扫描，设置未知初始值，然后逐步减少值，直到找到为止。几乎每个人都能通过这一步。你确定要退出吗？"

#: unit3.rstutorialstep3
msgid ""
"Ok, seeing that you've figured out how to find a value using exact value let's move on to the next step.\n"
"\n"
"First things first though. Since you are doing a new scan, you have to click on New Scan first, to start a new scan. (You may think this is straightforward, but you'd be surprised how many people get stuck on that step) I won't be explaining this step again, so keep this in mind.\n"
"Now that you've started a new scan, let's continue.\n"
"\n"
"In the previous test we knew the initial value so we could do an exact value search, but now we have a status bar where we don't know the starting value.\n"
"We only know that the value is between 0 and 500. And each time you click 'Hit me' you lose some health. The amount you lose each time is shown above the status bar.\n"
"\n"
"Again there are several different ways to find the value. (like doing a decreased value by... scan), but I'll only explain the easiest. \"Unknown initial value\", and decreased value.\n"
"Because you don't know the value it is right now, exact value won't do any good, so choose as scantype 'Unknown initial value', again, the value type is 4-bytes. (Most windows apps use 4-bytes.) Click First scan and wait till it's done.\n"
"\n"
"When it is done click 'Hit me'. You'll lose some of your health. (the amount you lost shows for a few seconds and then disappears, but you don't need that)\n"
"Now go to Cheat Engine, and choose 'Decreased Value' and click 'Next Scan'\n"
"When that scan is done, click 'Hit me' again, and repeat the above till you only find a few. \n"
"\n"
"We know the value is between 0 and 500, so pick the one that is most likely the address we need, and add it to the list.\n"
"Now change the health to 5000, to proceed to the next step."
msgstr ""
"好的，既然你已经学会了如何使用精确值来查找值，那我们继续下一步。\n"
"\n"
"首先，既然你要开始一个新的扫描，你必须先点击“新扫描”，以启动一个新的扫描。（你可能觉得这很简单，但你会惊讶于有多少人卡在了这一步）我不会再解释这一步了，所以请记住这一点。\n"
"现在你已经开始了新的扫描，我们继续。\n"
"\n"
"在之前的测试中，我们知道初始值，因此可以进行精确值搜索，但现在我们有一个状态条，我们不知道起始值。\n"
"我们只知道这个值在 0 到 500 之间。每次点击“点击我”，你会失去一些生命值。每次失去的数值会显示在状态条上方。\n"
"\n"
"同样，查找这个值有几种不同的方法。（比如进行“减少值”扫描），但我只会解释最简单的一种。“未知初始值”和“减少值”。\n"
"因为你不知道当前的值是多少，所以精确值搜索是没有用的。选择扫描类型为“未知初始值”，值类型仍然是 4 字节。（大多数 Windows 应用程序都使用 4 字节。）点击“首次扫描”并等待扫描完成。\n"
"\n"
"扫描完成后，点击“点击我”。你会失去一些生命值。（失去的数值会在几秒钟内显示出来，然后消失，但你不需要这个信息）\n"
"现在进入 Cheat Engine，选择“减少值”，并点击“下一次扫描”。\n"
"完成那次扫描后，再次点击“点击我”，并重复上述过程，直到你只找到几个地址。\n"
"\n"
"我们知道这个值在 0 到 500 之间，所以选择最有可能是我们需要的地址，并将其添加到列表中。\n"
"现在将生命值改为 5000，以便进入下一步。"

#: unit5.rsconfirmclose5
msgid "Come on. This step is simple. For health do a float scan, and for ammo a double type. (don't forget to disable fastscan for double in this case) Just ignore the fact that it looks different because it has a \".\" in the value. You sure you want to quit?"
msgstr "拜托了，这一步很简单。生命值用浮点数扫描，弹药用双精度类型扫描。（别忘了在这种情况下禁用快速扫描）别管它看起来不一样，因为它值里面有个“.”。你确定要退出吗？"

#: unit5.rsdead
#, object-pascal-format
msgid "I think you're dead!%sPress ok to become a brain eating zombie"
msgstr "我觉得你已经死了！%s按确定变成吃脑僵尸吧"

#: unit5.rsloser
msgctxt "unit5.rsloser"
msgid "BOO"
msgstr "失败！"

#: unit5.rsoutofammo
#, object-pascal-format
msgid "Out of ammo!%sPress ok to stock up on some ammo"
msgstr "弹药耗尽！%s按确定补充弹药"
#: unit5.rsstep4floatingpointspw
msgid "Step 4: Floating points (PW="
msgstr "步骤 4：浮点数（密码="

#: unit5.rstutorialstep4
msgid ""
"In the previous tutorial we used bytes to scan, but some games store information in so called 'floating point' notations. \n"
"(probably to prevent simple memory scanners from finding it the easy way)\n"
"a floating point is a value with some digits behind the point. (like 5.12 or 11321.1)\n"
"\n"
"Below you see your health and ammo. Both are stored as Floating point notations, but health is stored as a float and ammo is stored as a double.\n"
"Click on hit me to lose some health, and on shoot to decrease your ammo with 0.5\n"
" \n"
"You have to set BOTH values to 5000 or higher to proceed.\n"
"\n"
"Exact value scan will work fine here, but you may want to experiment with other types too.\n"
"\n"
"\n"
"\n"
"\n"
"\n"
"\n"
"\n"
"\n"
"\n"
"\n"
"\n"
"\n"
"\n"
"\n"
"Hint: It is recommended to disable \"Fast Scan\" for type double"
msgstr ""
"在之前的教程中，我们使用字节进行扫描，但有些游戏会以所谓的“浮点数”格式存储信息。\n"
"（可能是为了防止简单的内存扫描器轻松找到这些值）\n"
"浮点数是一个小数点后有几位数字的值。（例如 5.12 或 11321.1）\n"
"\n"
"在下面你可以看到你的生命值和弹药值。它们都以浮点数格式存储，但生命值是以单精度浮点数（float）存储的，而弹药是以双精度浮点数（double）存储的。\n"
"点击“点击我”会减少你的生命值，点击“射击”会减少 0.5 的弹药值。\n"
"\n"
"你需要将这两个值都设置为 5000 或更高，才能继续下一步。\n"
"\n"
"在这里，精确值扫描是可以正常工作的，但你也可以尝试使用其他类型的扫描。\n"
"\n"
"\n"
"\n"
"\n"
"\n"
"\n"
"\n"
"\n"
"\n"
"\n"
"\n"
"\n"
"\n"
"\n"
"提示：建议禁用双精度浮点数类型的“快速扫描”"

#: unit6.rsloser
msgctxt "unit6.rsloser"
msgid "BOO"
msgstr "失败！"

#: unit6.rsstep5codefinderpw
#, object-pascal-format
msgid "Step 5: Code finder (PW=%s)"
msgstr "步骤 5：代码查找器（密码=%s）"

#: unit6.rstryagain6
msgid "This may look difficult, but it shouldn't be. Basically find health, right click health, find what overwrites it, change health, click replace, change health, done.  But don't feel down if you don't get it. At least you know the basics of memory scanning...  Are you sure you want to quit?"
msgstr "这看起来可能有点难，但实际上并不复杂。基本步骤是：找到生命值，右键点击生命值，查找覆盖它的代码，修改生命值，点击替换，再次修改生命值，完成。如果你没成功，也别灰心，至少你已经掌握了内存扫描的基础知识……你确定要退出吗？"

#: unit6.rstutorialstep5
msgid ""
"Sometimes the location of a value is stored at changes, when you restart the game, or even while you're playing. In that case you can use 2 things to still make a table that works.\n"
"In this step I'll try to describe how to use the Code Finder function.\n"
"\n"
"The value down here will be at a different location each time you start the tutorial, so a normal entry in the address list wouldn't work.\n"
"First try to find the address. (You've got to this point so I assume you know how to do that.)\n"
"When you've found the address, right-click the address in Cheat Engine and choose \"Find out what writes to this address\". A window will pop up with an empty list.\n"
"Then click on the Change value button in this tutorial, and go back to Cheat Engine. If everything went right, there should be an address with assembler code there now.\n"
"Click it and choose the Replace option to replace it with code that does nothing. That will also add the code address to the code list in the Advanced Options window. (Which gets saved if you save your table.)\n"
"\n"
"Click on Stop, so the game will start running normal again, and click on Close to close the window.\n"
"Now, click on Change value, and if everything went right the Next button should become enabled.\n"
"\n"
"Note: When you're freezing the address with a high enough speed it may happen that Next becomes visible anyhow."
msgstr ""
"有时候，当你重新启动游戏，甚至在游戏进行中时，某个值的存储位置会发生变化。在这种情况下，你可以使用两种方法来创建一个仍然有效的表格。\n"
"在这一步中，我将尝试描述如何使用代码查找器功能。\n"
"\n"
"下面的这个值每次启动教程时都会位于不同的位置，因此普通的地址列表条目将无法工作。\n"
"首先，尝试找到该地址。（你已经到达了这一步，因此我假设你知道如何做到这一点。）\n"
"找到地址后，在 Cheat Engine 中右键点击该地址，并选择“查找写入此地址的内容”。此时会弹出一个带有空白列表的窗口。\n"
"然后点击本教程中的“更改值”按钮，再返回到 Cheat Engine。如果一切顺利，现在那里应该会出现一个带有汇编代码的地址。\n"
"点击该地址并选择“替换”选项，将其替换为不执行任何操作的代码。这也会将代码地址添加到高级选项窗口中的代码列表中。（如果你保存了表格，它也会被保存。）\n"
"\n"
"点击“停止”，以便游戏恢复正常运行，然后点击“关闭”以关闭窗口。\n"
"现在，点击“更改值”，如果一切顺利，“下一步”按钮应该会启用。\n"
"\n"
"注意：如果你以足够快的速度冻结地址，可能会出现“下一步”按钮无论如何都可见的情况。"

#: unit6.rswelldoneyouscrewedupthetutorial
msgctxt "unit6.rswelldoneyouscrewedupthetutorial"
msgid "Well done, you screwed up the tutorial!!!!"
msgstr "干得漂亮，你把教程搞砸了！！！！"

#: unit7.rsdontfuckingfreezethepointer
msgid "I'm sorry, but freezing the pointer is not really a functional solution"
msgstr "抱歉，冻结指针并不是一个有效的解决方案"

#: unit7.rsloser
msgctxt "unit7.rsloser"
msgid "BOO"
msgstr "失败！"

#: unit7.rsstep6pointerspw
#, object-pascal-format
msgid "Step 6: Pointers: (PW=%s)"
msgstr "步骤 6：指针（密码=%s）"

#: unit7.rstryagain7
msgid "So, pointers are too difficult eh? Don't worry, try again later. For most beginners this is difficult to grasp. But I have to tell you it's a powerful feature if you learn to use it. Are you sure you want to quit?"
msgstr "觉得指针太难了？别担心，以后还可以再试。对于大多数初学者来说，指针确实很难理解。但我必须告诉你，一旦你学会了如何使用它，它是一个非常强大的功能。你确定要退出吗？"

#: unit7.rstutorialstep6
msgid ""
"In the previous step I explained how to use the Code finder to handle changing locations. But that method alone makes it difficult to find the address to set the values you want.\n"
"That's why there are pointers:\n"
"\n"
"At the bottom you'll find 2 buttons. One will change the value, and the other changes the value AND the location of the value.\n"
"For this step you don't really need to know assembler, but it helps a lot if you do.\n"
"\n"
"First find the address of the value. When you've found it use the function to find out what accesses this address.\n"
"Change the value again, and an item will show up in the list. Double click that item. (or select and click on more info) and a new window will open with detailed information on what happened when the instruction ran.\n"
"If the assembler instruction doesn't have anything between a '[' and ']' then use another item in the list.\n"
"If it does it will say what it think will be the value of the pointer you need.\n"
"Go back to the main cheat engine window (you can keep this extra info window open if you want, but if you close it, remember what is between the '[' and ']' ) and do a 4 byte scan in hexadecimal for the value the extra info told you.\n"
"When done scanning it may return 1 or a few hundred addresses. Most of the time the address you need will be the smallest one. Now click on the \"Add Address Manually\" button and select the pointer checkbox.\n"
"\n"
"The window will change and allow you to type in the address of a pointer and an offset.\n"
"Fill in the address you just found. It can be in the form: \"Tutorial-i386.exe\"+xxxxxx (relative to the process), \n"
"or you can double click the address to add it to the address list and use the absolute address which appears there.\n"
"If the assembler instruction has a calculation (e.g: [esi+12]) at the end then type the value in that's at the end above the address field. This is the offset. Otherwise leave it 0. If it was a more complicated instruction look at the following calculation.\n"
"\n"
"Example of a more complicated instruction:\n"
"[EAX*2+EDX+00000310] eax=4C and edx=00801234.\n"
"In this case EDX would be the value the pointer has, and EAX*2+00000310 the offset, so the offset you'd fill in would be 2*4C+00000310=3A8. (This is all in hex, use calc.exe from Windows in Programmer mode to calculate hex values.)\n"
"\n"
"Back to the tutorial, click OK and the address will be added. If all went right the address will show P->xxxxxxx, with xxxxxxx being the address of the value you found. If that's not right, you've done something wrong.\n"
"Now, change the value using the pointer you added in to 5000 and click in the 'Active' column to freeze it. Then click Change pointer, and if all went right the Next button will become visible.\n"
"\n"
"\n"
"extra:\n"
"You could also use the pointer scanner to find the pointer to this address. <url id=\"d0ko49fpma9usmhr1nag\" type=\"url\" status=\"parsed\" title=\"Pointer scan\" wc=\"3001\">https://cheatengine.org/help/pointer-scan.htm</url> "
msgstr ""
"在上一步中，我解释了如何使用代码查找器来处理变化的地址。但仅靠这种方法很难找到你想要设置值的地址。\n"
"这就是指针的作用：\n"
"\n"
"在底部你会找到两个按钮。一个会改变值，另一个会同时改变值和值的地址。\n"
"这一步你不需要了解汇编语言，但如果你懂的话会很有帮助。\n"
"\n"
"首先找到值的地址。找到后，使用功能来查看什么访问了这个地址。\n"
"再次改变值，列表中会出现一个项目。双击该项目（或选择并点击更多信息），将打开一个新窗口，显示指令运行时的详细信息。\n"
"如果汇编指令在'['和']'之间没有任何内容，则使用列表中的另一个项目。\n"
"如果有的话，它会告诉你你需要的指针的值。\n"
"回到主 Cheat Engine 窗口（如果你想保留这个额外信息窗口可以保持打开，但如果关闭了，请记住'['和']'之间的内容），并进行一个 4 字节的十六进制扫描，扫描额外信息告诉你的值。\n"
"扫描完成后，可能会返回 1 个或几百个地址。大多数情况下，你需要的地址是最小的那个。现在点击“手动添加地址”按钮并选择指针复选框。\n"
"\n"
"窗口会改变，允许你输入指针的地址和偏移量。\n"
"填入你刚刚找到的地址。它可以是这种形式：\"Tutorial-i386.exe\"+xxxxxx（相对于进程），\n"
"或者你可以双击地址将其添加到地址列表中，并使用那里显示的绝对地址。\n"
"如果汇编指令在末尾有一个计算（例如：[esi+12]），则在地址字段上方的末尾输入该值。这就是偏移量。否则保留为 0。如果是更复杂的指令，请查看以下计算。\n"
"\n"
"更复杂指令的例子：\n"
"[EAX*2+EDX+00000310] eax=4C 和 edx=00801234。\n"
"在这种情况下，EDX 是指针的值，EAX*2+00000310 是偏移量，所以你输入的偏移量将是 2*4C+00000310=3A8。（这都是十六进制的，使用 Windows 的 calc.exe 在程序员模式下计算十六进制值。）\n"
"\n"
"回到教程，点击确定，地址将被添加。如果一切顺利，地址将显示为 P->xxxxxxx，其中 xxxxxxx 是你找到的值的地址。如果不对，说明你做错了。\n"
"现在，使用你添加的指针将值改为 5000，并在“激活”列中点击以冻结它。然后点击更改指针，如果一切顺利，“下一步”按钮将变得可见。\n"
"\n"
"\n"
"额外说明：\n"
"你也可以使用指针扫描器来找到这个地址的指针。<url id=\"d0ko49fpma9usmhr1nag\" type=\"url\" status=\"parsed\" title=\"指针扫描\" wc=\"3001\">https://cheatengine.org/help/pointer-scan.htm</url>"
#: unit7.rswelldoneyouscrewedupthetutorial
msgctxt "unit7.rswelldoneyouscrewedupthetutorial"
msgid "Well done, you screwed up the tutorial!!!!"
msgstr "干得漂亮，你把教程搞砸了！！！！"

#: unit7.rsyouvegotsecondslefttochangethevalueto5000
#, object-pascal-format
msgid "You have %s second%s left to change the value to 5000"
msgstr "你还有 %s 秒%s 来将值改为 5000"

#: unit8.rsawyouredeathletmereviveyou
msgctxt "unit8.rsawyouredeathletmereviveyou"
msgid "Aw, you're dead! Let me revive you"
msgstr "哎呀，你死了！让我帮你复活"

#: unit8.rshealth
msgid "Health"
msgstr "生命值"

#: unit8.rsloser
msgctxt "unit8.rsloser"
msgid "BOO"
msgstr "失败！"

#: unit8.rsstep7codeinjectionpw
#, object-pascal-format
msgid "Step 7: Code Injection: (PW=%s)"
msgstr "步骤 7：代码注入（密码=%s）"

#: unit8.rstryagain8
msgid "Code injections too tough? No problem, memory scanning and basic pointers should be enough to get you experienced enough and you can always try the tutorial later. Are you sure you want to quit?"
msgstr "代码注入太难了？没关系，内存扫描和基本指针的学习应该足以让你积累经验，你随时可以再试一次教程。你确定要退出吗？"

#: unit8.rstutorialstep7
msgid ""
"Code injection is a technique where you inject a piece of code into the target process, and then reroute the execution of code to go through your own written code.\n"
"\n"
"In this tutorial you'll have a health value and a button that will decrease your health by 1 each time you click it.\n"
"Your task is to use code injection to make the button increase your health by 2 each time it is clicked.\n"
"\n"
"Start with finding the address and then find what writes to it.\n"
"Then when you've found the code that decreases it browse to that address in the disassembler, and open the auto assembler window (Ctrl+A).\n"
"There click on template and then code injection, and give it the address that decreases health (if it isn't already filled in correctly).\n"
"That will generate a basic auto assembler injection framework you can use for your code.\n"
"\n"
"Notice the alloc, that will allocate a block of memory for your code cave, in the past, in the pre windows 2000 systems, people had to find code caves in the memory (regions of memory unused by the game), but that's luckily a thing of the past since windows 2000, and will these days cause errors when trying to be used, due to SP2 of XP and the NX bit of new CPUs.\n"
"\n"
"Also notice the line newmem: and originalcode: and the text \"Place your code here\".\n"
"As you guessed it, write your code here that will increase the health with 2.\n"
"A useful assembler instruction in this case is the \"ADD instruction\".\n"
"\n"
"Here are a few examples:\n"
"\"ADD [00901234],9\" to increase the address at 00901234 with 9\n"
"\"ADD [ESP+4],9\" to increase the address pointed to by ESP+4 with 9\n"
"In this case, you'll have to use the same thing between the brackets as the original code has that decreases your health.\n"
"\n"
"Notice:\n"
"It is recommended to delete the line that decreases your health from the original code section, else you'll have to increase your health with 3 (you increase with 3, the original code decreases with 1, so the end result is increase with 2), which might become confusing. But it's all up to you and your programming.\n"
"\n"
"Notice 2:\n"
"In some games the original code can exist out of multiple instructions, and sometimes, not always, it might happen that a code at another place jumps into your jump instruction end will then cause unknown behavior. If that happens, you should usually look near that instruction and see the jumps and fix it, or perhaps even choose to use a different address to do the code injection from. As long as you're able to figure out the address to change from inside your injected code."
msgstr ""
"代码注入是一种技术，你将一段代码注入到目标进程中，然后重新定向代码的执行流程，使其通过你编写的代码。\n"
"\n"
"在这个教程中，你有一个生命值和一个按钮，每次点击该按钮，你的生命值会减少 1。\n"
"你的任务是使用代码注入，使每次点击该按钮时，你的生命值增加 2。\n"
"\n"
"首先找到该地址，然后查看什么代码在写入它。\n"
"找到减少生命值的代码后，在反汇编器中浏览该地址，并打开自动汇编窗口（Ctrl+A）。\n"
"在那里点击模板，然后选择代码注入，并输入减少生命值的地址（如果尚未正确填写）。\n"
"这将生成一个基本的自动汇编注入框架，你可以用它来编写代码。\n"
"\n"
"注意分配内存的部分，它会为你的代码洞分配一块内存。在过去，Windows 2000 之前的系统中，人们需要在内存中找到代码洞（游戏中未使用的内存区域），但幸运的是，自从 Windows 2000 以来，这种情况已经不存在了。由于 XP 的 SP2 和新 CPU 的 NX 位，现在使用这种方法会导致错误。\n"
"\n"
"还要注意 newmem: 和 originalcode: 这两行，以及“在此处放置代码”的文本。\n"
"正如你所猜测的，你需要在这里编写增加 2 点生命值的代码。\n"
"在这种情况下，一个有用的汇编指令是“ADD 指令”。\n"
"\n"
"以下是一些示例：\n"
"“ADD [00901234],9” 用于将地址 00901234 的值增加 9\n"
"“ADD [ESP+4],9” 用于将 ESP+4 指向的地址的值增加 9\n"
"在这种情况下，你需要使用与原始代码中减少生命值的部分相同的括号内的内容。\n"
"\n"
"注意：\n"
"建议从原始代码部分删除减少生命值的行，否则你需要将生命值增加 3（你增加 3，原始代码减少 1，最终结果是增加 2），这可能会让人感到困惑。但这取决于你和你的编程方式。\n"
"\n"
"注意 2：\n"
"在某些游戏中，原始代码可能由多条指令组成，有时（但并非总是），可能会发生其他地方的代码跳转到你的跳转指令的末尾，从而导致未知行为。如果发生这种情况，你通常需要查看该指令附近的跳转，并进行修复，或者甚至选择使用不同的地址进行代码注入。只要你能从注入的代码中找出要修改的地址即可。"

#: unit9.rsloser
msgctxt "unit9.rsloser"
msgid "BOO"
msgstr "失败！"

#: unit9.rsstep8multilevelpointerspw
#, object-pascal-format
msgid "Step 8: Multilevel pointers: (PW=%s)"
msgstr "步骤 8：多级指针（密码=%s）"

#: unit9.rstryagain9
msgid "Aw, you've almost reached the end. But don't worry, multilevel pointers can be a real pain when dealing with. If you get more experienced someday you can try it again. Are you sure you want to quit?"
msgstr "哎呀，你已经快到终点了。别担心，多级指针确实很难处理。等你以后更有经验了可以再试一次。你确定要退出吗？"

#: unit9.rstutorialstep8
msgid ""
"This step will explain how to use multi-level pointers.\n"
"In step 6 you had a simple level-1 pointer, with the first address found already being the real base address.\n"
"This step however is a level-4 pointer. It has a pointer to a pointer to a pointer to a pointer to a pointer to the health.\n"
"\n"
"You basically do the same as in step 6. Find out what accesses the value, look at the instruction and what probably is the base pointer value, and what is the offset, and already fill that in or write it down. But in this case the address you'll find will also be a pointer. You just have to find out the pointer to that pointer exactly the same way as you did with the value. Find out what accesses that address you found, look at the assembler instruction, note the probable instruction and offset, and use that.\n"
"And continue till you can't get any further (usually when the base address is a static address, shown up as green.)\n"
"\n"
"Click Change Value to let the tutorial access the health.\n"
"If you think you've found the pointer path click Change Register. The pointers and value will then change and you'll have 3 seconds to freeze the address to 5000.\n"
"\n"
"Extra: This problem can also be solved using an auto assembler script, or using the pointer scanner.\n"
"Extra2: In some situations it is recommended to change CE's Codefinder settings to Access violations when \n"
"encountering instructions like mov eax,[eax] since debug registers show it AFTER it was changed, making it hard to find out the value of the pointer.\n"
"\n"
"\n"
"\n"
"\n"
"\n"
"Extra3: If you're still reading. You might notice that when looking at the assembler instructions that the pointer is being read and filled out in the same codeblock (same routine, if you know assembler, look up till the start of the routine). This doesn't always happen, but can be really useful in finding a pointer when debugging is troublesome."
msgstr ""
"本步骤将解释如何使用多级指针。\n"
"在第 6 步中，你有一个简单的 1 级指针，找到的第一个地址已经是实际的基地址。\n"
"然而，这一步是一个 4 级指针。它有一个指向指向指向指向指向生命值的指针的指针。\n"
"\n"
"你基本上按照第 6 步的方法操作。找出什么访问了该值，查看指令以及可能的基指针值和偏移量，并记录下来。但在这个例子中，你找到的地址本身也是一个指针。你需要以同样的方式找出指向该指针的指针。查看访问该地址的指令，记录可能的指令和偏移量，并使用它们。\n"
"继续这个过程，直到你无法再进一步（通常当基地址是一个静态地址，显示为绿色时）。\n"
"\n"
"点击“更改值”让教程访问生命值。\n"
"如果你认为你已经找到了指针路径，点击“更改寄存器”。指针和值将会改变，你将有 3 秒钟的时间将地址冻结为 5000。\n"
"\n"
"额外说明：这个问题也可以通过自动汇编脚本或指针扫描器来解决。\n"
"额外说明 2：在某些情况下，建议将 CE 的代码查找器设置更改为访问违规，当遇到类似 mov eax,[eax] 的指令时，调试寄存器会在更改后显示，这使得很难找到指针的值。\n"
"\n"
"\n"
"\n"
"\n"
"\n"
"额外说明 3：如果你还在阅读，你可能会注意到，在查看汇编指令时，指针是在同一个代码块（相同的例程）中被读取并填充的（如果你懂汇编，可以一直追溯到例程的开始）。这种情况并不总是发生，但在调试过程中，这可以非常有助于找到指针。"

#: unit9.rsunrandomizerdetected
msgid "Unrandomizer detected"
msgstr "检测到非随机化器"

#: unit9.rsyouvegotsecondslefttochangethevalueto5000
#, object-pascal-format
msgid "You've got %s seconds left to change the value to 5000"
msgstr "你还有 %s 秒来将值改为 5000"
