msgid ""
msgstr ""
"Content-Type: text/plain; charset=UTF-8\n"
"Plural-Forms: nplurals=1; plural=0;\n"
"Project-Id-Version: \n"
"POT-Creation-Date: \n"
"PO-Revision-Date: \n"
"Last-Translator: \n"
"Language-Team: \n"
"MIME-Version: 1.0\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: zh_CN\n"
"X-Generator: Poedit 2.2.3\n"

#: tform1.btnok.caption
msgid "OK"
msgstr "确定"

#: tform1.button1.caption
msgctxt "tform1.button1.caption"
msgid "Next"
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 "C. 玩家 3：HAL"

#: tform10.label8.caption
msgctxt "tform10.label8.caption"
msgid "Health: 500"
msgstr "血量：500"

#: tform10.label9.caption
msgid "C. Player 4: KITT"
msgstr "C. 玩家 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 "跳过"

#: 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.4)\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!\n"
msgstr ""
"欢迎来到 Cheat Engine 教程 (v3.4)\n"
"这个教程会教你在游戏中作弊的基本知识，并且向你展示使用 Cheat Engine 基本的方面。跟着下面的步骤开始吧\n"
"1: 打开 Cheat Engine 如果它现在还没运行\n"
"2: 点击“打开进程”图标（左上角的电脑图标，在“文件”下面\n"
"3: 进程列表窗口打开时，在列表中找到教程的进程，它看起来像 “00001234-Tutorial-x86_64.exe” （前面的八个数字可能会不一样）\n"
"4: 一旦你找到这个进程，点击它来选中，然后点“打开”按钮 。（先别管其它按钮，如果你感兴趣，你会在后面学到它们）\n"
"恭喜！如果你都做对了，进程窗口会消失，现在 Cheat Engine 附在教程上了（你会在Cheat Engine上面中间的位置看到进程的名字）\n"
"点击下面的“下一步”按钮来继续，或者输入密码并确认跳转到相应步骤\n"
"如果你有任何问题，就到 forum.cheatengine.org，然后点击“教程”来查看对新手友好的指导！\n"

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

#: unit10.rsfailureyourteamdied
msgid "Failure. Your team died"
msgstr "失败，团灭了"

#: unit10.rshealth
msgid "Health: %s"
msgstr "血量：%s"

#: unit10.rsrestartgameandautoplay
msgctxt "unit10.rsrestartgameandautoplay"
msgid "Restart game and autoplay"
msgstr "重启游戏并自动执行"

#: unit10.rsstep9sharedcodepw
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\n"
msgstr ""
"这一步会解释如何处理，其它相同类型对象使用的共享代码\n"
"\n"
"通常在你找到一个单位的血量，或是你自己角色的血量，你会发现如果你把血量相关代码移除，这也会影响到敌人\n"
"在这种情况下，你必须想办法区分你和敌人的对象\n"
"有时候很简单, 你只要检查最前面的4个字节(函数指针表), 它通常指向一个独一无二的地址, 代表着玩家角色，而有的时候它是一个团体号码, 或者是一个指向指针的指针的指针的指针, 最后指向一个玩家名字。总之完全取决于游戏的复杂度, 以及你的运气\n"
"最简单的方法是找到代码改写了哪个地址，然后使用分析数据功能来比较两个结构（你的角色和敌人），看能否找到一个方法区分它们\n"
"当你找出怎么区分你和电脑后，就可以注入汇编脚本来检查条件，然后不执行代码或者做别的事情（比如一击必杀）\n"
"另外，你还可以用这个方法创建一个叫“字节数组”的字符串，它能搜索并列出所有你的角色和敌人\n"
"在这个教程中，我已经实现了你将会玩到的最惊人的游戏\n"
"这个游戏有4个玩家。2个属于你的队伍, 另外两个属于电脑方\n"
"你的任务是找到并修改血量的代码，使你不用冻结自己的血量就能获胜\n"
"接着按 \"重启游戏并自动执行\" 来测试你的代码是否正确\n"
"\n"
"\n"
"提示1：血量是单浮点数\n"
"提示2：有很多解法\\n\n"

#: 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 a 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'\n"
msgstr ""
"现在你已经在Cheat Engine中打开了教程，让我们开始下一步\n"
"\n"
"你可以看到窗口底部的血量文字\n"
"每次你点“打我”，你的血量就会下降\n"
"\n"
"要到下一步骤，你需要把血量改成1000\n"
"\n"
"有不同的方法找到血量，但是我会告诉你最简单的那个——“精确值”：\n"
"首先把数值类型设置为最少2字节或4字节，1字节也行，不过修改的时候会有点麻烦（虽说很容易解决）。如果地址后面的字节都是0，那你可以设置成8字节\n"
"单浮点，双浮点，和其它扫描不会工作，因为它们存储数值的方式不同\n"
"当数值类型设置正确后，确认扫描类型设为“精确值”\n"
"然后输入血量并点击“首次扫描”\n"
"等会扫描完毕，结果会显示在左边的列表\n"
"如果你找到了超过一个地址，而且无法确认哪个才是真的，点“打我”再输入新的数值并点“再次扫描”\n"
"重复这步直到你确定找到真正的地址（列表中只有一个地址）\n"
"\n"
"现在双击这个地址，它会出现在窗口下面，显示当前的数值\n"
"双击数值（或选中，按回车），把数值改成1000\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, unkown 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 straighforward, 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 a exact value, 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, a exact value wont 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.\n"
msgstr ""
"OK，看来你已经学会怎么用精确值查找数值，让我们进行下一步\n"
"在之前的测试我们知道初始值，所以可以用精确值扫描。但现在我们只有一个不知道初始值的血条\n"
"扫描未知的初始值，4字节。重复“打我”和再次扫描“减少的数值”，直到找出真正的地址\n"
"血量改成5000，进入下一步\n"
"（原文很啰嗦，不翻译了）\n"

#: 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
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
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\n"
msgstr ""
"在之前的教程中我们用字节来扫描，但有些游戏使用“浮点数”存储数值 \n"
" （可能是防止菜鸟轻松修改数值）\n"
"一个浮点数是带小数点的数值（如 5.13 或 11321.1）\n"
"\n"
"下面你看到你的血量和子弹，两个都是浮点数，但血量是单浮点，而子弹是双浮点\n"
"点击“打我”减少血量，“开枪”减少 0.5 子弹\n"
"\n"
"你需要把两个数值改成5000或更高来过关\n"
"\n"
"精确值扫描在这里也能用，但你也要尝试其它类型\n"
"\n"
"\n"
"提示：建议在用双浮点扫描时关闭“快速扫描”\n"

#: unit6.rsloser
msgctxt "unit6.rsloser"
msgid "BOO"
msgstr "_(:з」∠)_"

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

#: unit6.rstryagain6
msgid "This may look difficult. but it's basicly. Find health, rigthclick health, find what writes, change health, click replace, change health, done.  But don't feel down if you don't get it. at least you know the basicas of memory scanning...  Are you sure you want to quit?"
msgstr "这看起来很难，但这是基本功，找到血量，右键点击找出是什么改写了它，点替换就完了。确认退出？"

#: unit6.rstutorialstep5
msgid ""
"Sometimes the location of where something 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)\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 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\n"
msgstr ""
"有时当你重启游戏甚至正在玩的时候，数值存储位置会改变。在那种情况下你可以用两个东西来使修改表还能工作。\n"
"在这一步我会试着描述怎么使用“代码查找”功能\n"
"下面的数值每次都会在教程启动时存放在不同位置，所以地址列表中的条目是没用的\n"
"首先试着找到地址（我假设你知道怎么做到这点）\n"
"当你找到地址，在地址上右键点“找出谁改写了这个地址”，会弹出一个空的窗口\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
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 a item will show 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 manually add and select the pointer checkbox.\n"
"\n"
"The window will change and allow you to type in the address of a pointer and a offset.\n"
"Fill in as address the address you just found.\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. else leave it 0. If it was a more complicated instruction look at the 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 scientific mode to calculate)\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 thats not right, you've done something wrong.\n"
"Now, change the value using the pointer you added in 5000 and freeze it. Then click Change pointer, and if all went \n"
"right the next button will become visible.\n"
"\n"
"\n"
"extra:\n"
"And you could also use the pointer scanner to find the pointer to this address\n"
msgstr ""
"上一步我解释了怎么用代码查找处理改变的地址，但只用那个方法很难找到你要修改数值的地址\n"
"这就是为什么我们要用到指针\n"
"下面有两个按钮，一个改变数值，另一个同时改变数值和地址\n"
"这一步你不需要懂汇编，但如果你懂会很有帮助\n"
"首先找到数值的地址，然后找出是谁改写了这个地址\n"
"再次改变数值，列表中会出现一个项目，双击它（或者选中再点更多信息），一个新的窗口会打开，显示指令执行时的详细信息\n"
"如果这条汇编指令的 [ ] 里面没有东西，就用列表中其它项目\n"
"如果有就说明这是我们要的指针\n"
"回到 Cheat Engine 主窗口（你可以留着信息窗口，关的话就要记着 [ ] 里的东西），然后用4字节扫描详细信息窗口告诉你的十六进制数值\n"
"扫描完成后它可能返回一个或几百个地址，多数时候你需要选择最小那个。现在点“手动添加地址”并勾选“指针”\n"
"窗口会改变并允许你输入指针的地址和偏移\n"
"输入你刚才找到的地址\n"
"如果汇编指令后面有一个计算（如：esi+12），把后面的数值填在偏移里，否则保持为0。如果指令很复杂请看计算方法\n"
"\n"
"一个复杂指令的例子：\n"
"[EAX*2+EDX+00000310] eax=4C and edx=00801234\n"
"这种情况下EDX是数值的指针，EAX*2+00000310是偏移，所以你要填的偏移是3A8（可以用微软的科学计算器来算）\n"
"\n"
"回到教程，点击确定，这个地址会添加到主窗口下面的地址列表，显示P->xxxxx，xxxxx跟你找到的数值地址一样\n"
"现在使用这个指针改变数值为5000并锁定，点击改变指针，没问题的话下一步将可用\n"
"\n"
"你也可以用指针扫描找到这个地址\n"

#: unit7.rswelldoneyouscrewedupthetutorial
msgctxt "unit7.rswelldoneyouscrewedupthetutorial"
msgid "Well done, you screwed up the tutorial!!!!"
msgstr "做得好，你搞砸了这个教程！！！"

#: unit7.rsyouvegotsecondslefttochangethevalueto5000
msgid "You have %s second%s left to change the value to 5000"
msgstr "你还有 %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
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 CPU's\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"
"An usefull assembler instruction in this case is the \"ADD instruction\"\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.\n"
msgstr ""
"代码注入是个技术活，你要把一段代码注入到目标进程，使它执行你的代码\n"
"\n"
"在这个教程，你有一个血量，和每按一次就减少一点血的按钮\n"
"你的任务是用代码注入使按钮每次给你加两点血\n"
"\n"
"找到地址和谁改写了它\n"
"在内存浏览器中查看使血量减1的汇编代码，打开自动汇编窗口（ctrl+a）\n"
"点模板选择代码注入，输入汇编代码的地址（如果没有自动输入正确的地址）\n"
"这会生成一个基本的自动汇编注入框架给你的代码使用\n"
"\n"
"注意把你的代码写在“Place your code here”下面\n"
"在这种情况下，一个有用的汇编指令是 ADD\n"
"这是一些例子：\n"
"ADD [00901234],9——地址 00901234 加 9\n"
"ADD [ESP+4],9——ESP+4 指向的地址加 9\n"
"在本关的情况下，你需要使用那条减少血量的代码\n"
"\n"
"建议你直接修改originalcode；或者删除原来减少一点血的代码，加一条加两点血的代码；或者增加三点血量，这样结果是增加二，由你决定\n"
"\n"
"提示 2：\n"
"在某些游戏里，原代码在多条指令之外，有时候，可能发生其它地方的一段代码跳转到你的跳转指令后面，导致未知行为。如果这样，你通常要看看附近的跳转指令来修复它，或者可能要选另一个地址来注入代码，只要你能从你的注入代码里找到要改变的地址\n"

#: unit9.rsloser
msgctxt "unit9.rsloser"
msgid "BOO"
msgstr "_(:з」∠)_"

#: unit9.rsstep8multilevelpointerspw
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 basicly 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 a 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 debugregisters show it AFTER it was changed, making it hard to find out the 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\n"
msgstr ""
"这一步会解释如何使用多级指针\n"
"在步骤 6 的是一级指针，第一个地址就能找到基址\n"
"在这里的是四级指针，指向血量的指针的指针的指针的指针\n"
"基本操作和步骤 6 相同，找出谁改写了这个数值，记下偏移值，继续找谁访问了指针，直到找不到为止（通常基址为静态时显示绿色）\n"
"点击改变指针，你有三秒钟时间把数值改成5000并锁定\n"
"\n"
"提示 1：这个问题可以用自动汇编脚本或者指针扫描器解决\\n\"\n"
"提示 2：有的情况下建议改变CE的代码查找设置为非法访问，当你遇到类似 mov eax,[eax] 的指令，调试寄存器会显示改变后的值，使它难以找到指针的数值\\n\"\n"
"译者注：我不知道Access violations这东西在哪，当你遇到 mov rsi,[rsi]这种情况，另一条在列表里的指令 cmp qword ptr [rsi],00 会帮你找到地址\\n\"\n"
"提示 3：如果你还在读。当你查看汇编指令时可能注意到，这些指针在相同的代码块被读写（相同的程序，如果你懂汇编，查看程序开始的位置），这种情况不是总会发生，当你查找指针遇到麻烦，这会很有用\\n\"\n"

#: unit9.rsunrandomizerdetected
msgid "Unrandomizer detected"
msgstr "检测到 Unrandomizer"

#: unit9.rsyouvegotsecondslefttochangethevalueto5000
msgid "You've got %s seconds left to change the value to 5000"
msgstr "你还有 %s 秒时间改变数值为5000"
