求psi 1.16 最新版汉化 - Mod问答

zlptq.zzb

本帖最后由 zlptq.zzb 于 2021-1-1 22:44 编辑

psi：https://www.curseforge.com/minecraft/mc-mods/psi
求汉化文件
---------------------------------------------------2021.1.1
用有道翻译了一小部分，有大佬能帮忙继续汉化一些吗？

{
"itemGroup.psi": "Psi",
"psi.desc": "这是一个打破第四堵墙的笑话，享受吧.",
"psimisc.shift_for_info": "§7按 §bSHIFT§7 查看详情",
"psimisc.component_type": "§a部件类型§7: %s",
"psimisc.none": "(无)",
"psimisc.stats": "属性",
"psimisc.socketing": "弹夹",
"psimisc.keybind": "Psi控制键位绑定",
"psimisc.selected": "选中",
"psimisc.spell_selected": "§d选定魔法式§7: %s",
"psimisc": "名称:",
"psimisc.compiled": "编译成功",
"psimisc.errored": "编译错误",
"psimisc.weak_cad": "你的CAD属性还不足以施展这个魔法式.",
"psimisc.canceled_spell": "有什么东西阻止了你施那个术式.",
"psimisc.cancelled_cad_take": "有什么东西阻止了你制作CAD.",
"psimisc.constant": "常量",
"psimisc.next_page": "下一页",
"psimisc.prev_page": "上一页",
"psimisc.config": "Config",
"psimisc.not_your_programmer": "似乎还有其他人正在使用. 最好还是不要打扰了.",
"psimisc.cant_use_programmer": "你还不知道怎样使用这个东西.",
"psimisc.level_display": "等级 %d",
"psimisc.level_info": "等级 %d - 等级点: %d",
"psimisc.level_info_creative": "等级 %d (创造) - 等级点: %d",
"psimisc.locked": "锁定",
"psimisc.requirements": "需求",
"psimisc.learn": "学习",
"psimisc.levelup": "升级",
"psimisc.wip": "Psi Beta | Not final!",
"psimisc.bullet_type": "§b型号§7: %s",
"psimisc.bullet_cost": "§b能量消耗§7: %s%%",
"psimisc.level_up_info1": "你获得了1个等级点",
"psimisc.level_up_info2": "卸下你的CAD然后按[%s]来使用新的点数!",
"psimisc.import_from_clipboard": "从剪贴板导入",
"psimisc.export_to_clipboard": "导出至剪贴板",
"psimisc.must_hold_shift": "(必须按住SHIFT)",
"psimisc.malformed_json": "导入错误: 字符串有缺陷.",
"psimisc.missing_pieces": "导入错误: 导入魔法式丢失.",
"psimisc.load_prompt": "Load?",
"psimisc.spectator": "[Spectator Mode]",
"psimisc.multiple_cads": "物品栏中另一台CAD干涉了你的施法. 你最多只能持有一台CAD.",
"psimisc.provider_mod": "§7Addon: §9%s",
"psimisc.trick_pattern": "^Trick: (.+)$",
"psimisc.programmer_help": "§a编程帮助",
"psimisc.ctrl_windows": "Ctrl",
"psimisc.ctrl_mac": "Cmd",
"psimisc.enter_commit": "Press Enter to commit",
"psimisc.semicolon_line": "Use ; to change line",
"psimisc.programmer_coords": "选定: [%d, %d] | 光标: [%d, %d]",
"psimisc.programmer_coords_no_cursor": "选定: [%d, %d]",
"psimisc.name": "名称",
"psimisc.requiredaddons": "需要附属: ",
"psimisc.modnotfound": "你试图导入的术式不会被完整导入，因为它使用了来自未安装mod %d 的符号",
"psimisc.spellonnewerversion": "这个咒语是用新版本的Psi创造的;它可能会也可能不会像预期的那样工作.",
"psi.container.socketable": "插座",
"psi.subtitle.bullet_create": "启动式已储存",
"psi.subtitle.cad_create": "CAD配装成功",
"psi.subtitle.spell_cast": "魔法式发动",
"psi.subtitle.loopcast": "循环演算",
"block.psi.cad_assembler": "CAD装配器",
"block.psi.programmer": "术式编写台",
"block.psi.psidust_block": "Psi粉块",
"block.psi.psimetal_block": "Psi金属块",
"block.psi.psigem_block": "Psi宝石块",
"block.psi.black_psimetal_plate": "深色Psi金属板",
"block.psi.lit_black_psimetal_plate": "深色Psi金属流光板",
"block.psi.white_psimetal_plate": "亮色Psi金属板",
"block.psi.lit_white_psimetal_plate": "亮色Psi金属流光板",
"block.psi.ebony_psimetal_block": "乌黑色Psi金属块",
"block.psi.ivory_psimetal_block": "乳白色Psi金属块",
"block.psi.conjured": "构筑方块",
"block.psi.psimetal_plate_white": "亮色Psi金属板",
"block.psi.psimetal_plate_white_light": "亮色Psi金属流光板",
"item.psi.psidust": "Psi粉",
"item.psi.psimetal": "Psi金属锭",
"item.psi.psigem": "Psi宝石",
"item.psi.ebony_psimetal": "乌黑色Psi金属锭",
"item.psi.ivory_psimetal": "乳白色Psi金属锭",
"item.psi.ebony_substance": "乌黑色物质",
"item.psi.ivory_substance": "乳白色物质",
"item.psi.cad": "术式辅助演算机",
"item.psi.cad_assembly_iron": "铁质CAD机体",
"item.psi.cad_assembly_gold": "金质CAD机体",
"item.psi.cad_assembly_psimetal": "Psi金属CAD机体",
"item.psi.cad_assembly_ebony_psimetal": "乌黑色Psi金属CAD机体",
"item.psi.cad_assembly_ivory_psimetal": "乳白色Psi金属CAD机体",
"item.psi.cad_assembly_creative": "创造版CAD机体",
"item.psi.cad_core_basic": "基础CAD核心",
"item.psi.cad_core_overclocked": "超频CAD核心",
"item.psi.cad_core_conductive": "传导CAD核心",
"item.psi.cad_core_hyperclocked": "极频CAD核心",
"item.psi.cad_core_radiative": "辐射CAD核心",
"item.psi.cad_socket_basic": "基础CAD弹夹",
"item.psi.cad_socket_signaling": "信号CAD弹夹",
"item.psi.cad_socket_large": "大型CAD弹夹",
"item.psi.cad_socket_transmissive": "透射CAD弹夹",
"item.psi.cad_socket_huge": "巨型CAD弹夹",
"item.psi.cad_battery_basic": "基础CAD电池",
"item.psi.cad_battery_extended": "扩容CAD电池",
"item.psi.cad_battery_ultradense": "超密CAD电池",
"item.psi.cad_colorizer_white": "白色 CAD着色器",
"item.psi.cad_colorizer_orange": "橙色 CAD着色器",
"item.psi.cad_colorizer_magenta": "品红色 CAD着色器",
"item.psi.cad_colorizer_light_blue": "淡蓝色 CAD着色器",
"item.psi.cad_colorizer_yellow": "黄色 CAD着色器",
"item.psi.cad_colorizer_lime": "黄绿色 CAD着色器",
"item.psi.cad_colorizer_pink": "粉色 CAD着色器",
"item.psi.cad_colorizer_gray": "灰色 CAD着色器",
"item.psi.cad_colorizer_light_gray": "淡灰色 CAD着色器",
"item.psi.cad_colorizer_cyan": "青色 CAD着色器",
"item.psi.cad_colorizer_purple": "紫色 CAD着色器",
"item.psi.cad_colorizer_blue": "蓝色 CAD着色器",
"item.psi.cad_colorizer_brown": "棕色 CAD着色器",
"item.psi.cad_colorizer_green": "绿色 CAD着色器",
"item.psi.cad_colorizer_red": "红色 CAD着色器",
"item.psi.cad_colorizer_black": "黑色 CAD着色器",
"item.psi.cad_colorizer_rainbow": "全色 CAD着色器",
"item.psi.cad_colorizer_psi": "Psi CAD着色器",
"item.psi.cad_colorizer_empty": "耗尽的CAD着色器",
"item.psi.spell_bullet": "术式子弹",
"item.psi.spell_bullet_active": "术式子弹(已编译)",
"item.psi.spell_bullet_projectile": "投射型术式子弹",
"item.psi.spell_bullet_projectile_active": "投射型术式子弹(已编译)",
"item.psi.spell_bullet_loop": "循环型术式子弹",
"item.psi.spell_bullet_loop_active": "循环型术式子弹(已编译)",
"item.psi.spell_bullet_circle": "圈阵型术式子弹",
"item.psi.spell_bullet_circle_active": "圈阵型术式子弹(已编译)",
"item.psi.spell_bullet_grenade": "榴弹型术式子弹",
"item.psi.spell_bullet_grenade_active": "榴弹型术式子弹(已编译)",
"item.psi.spell_bullet_charge": "遥控型术式子弹",
"item.psi.spell_bullet_charge_active": "遥控型术式子弹(已编译)",
"item.psi.spell_bullet_mine": "地雷型术式子弹",
"item.psi.spell_bullet_mine_active": "地雷型术式子弹(已编译)",
"item.psi.spell_drive": "术式驱动器",
"item.psi.psimetal_shovel": "Psi金属锹",
"item.psi.psimetal_pickaxe": "Psi金属镐",
"item.psi.psimetal_axe": "Psi金属斧",
"item.psi.psimetal_sword": "Psi金属剑",
"item.psi.psimetal_shovel.broken": "损坏的Psi金属锹",
"item.psi.psimetal_pickaxe.broken": "损坏的Psi金属镐",
"item.psi.psimetal_axe.broken": "损坏的Psi金属剑",
"item.psi.psimetal_sword.broken": "损坏的Psi金属剑",
"item.psi.detonator": "术式引发器",
"item.psi.psimetal_exosuit_helmet": "Psi金属套装头盔",
"item.psi.psimetal_exosuit_chestplate": "Psi金属套装胸甲",
"item.psi.psimetal_exosuit_leggings": "Psi金属套装护腿",
"item.psi.psimetal_exosuit_boots": "Psi金属套装靴子",
"item.psi.psimetal_exosuit_helmet.broken": "损坏的Psi金属套装头盔",
"item.psi.psimetal_exosuit_chestplate.broken": "损坏的Psi金属套装胸甲",
"item.psi.psimetal_exosuit_leggings.broken": "损坏的Psi金属套装护腿",
"item.psi.psimetal_exosuit_boots.broken": "损坏的Psi金属套装靴子",
"item.psi.exosuit_controller": "套装控制器",
"item.psi.exosuit_sensor_light": "光传感器",
"item.psi.exosuit_sensor_water": "水传感器",
"item.psi.exosuit_sensor_heat": "热传感器",
"item.psi.exosuit_sensor_stress": "压力传感器",
"item.psi.exosuit_sensor_trigger": "触发传感器",
"item.psi.vector_ruler": "向量尺",
"death.attack.psi-overload": "%s 耗尽了他的psi能量",
"psi.component.assembly": "机体",
"psi.component.core": "核心",
"psi.component.socket": "弹夹",
"psi.component.battery": "电池",
"psi.component.dye": "着色器",
"psi.cadstat.efficiency": "效率",
"psi.cadstat.potency": "强度",
"psi.cadstat.complexity": "复杂度",
"psi.cadstat.projection": "映射",
"psi.cadstat.bandwidth": "带宽",
"psi.cadstat.sockets": "弹夹",
"psi.cadstat.overflow": "溢值",
"psi.spellstat.complexity": "复杂度",
"psi.spellstat.complexity.desc": "动作数",
"psi.spellstat.potency": "强度",
"psi.spellstat.potency.desc": "魔法式的威力",
"psi.spellstat.cost": "消耗",
"psi.spellstat.cost.desc": "施展魔法式的Psi能量消耗",
"psi.spellstat.projection": "映射",
"psi.spellstat.projection.desc": "启动式总数",
"psi.spellstat.bandwidth": "带宽",
"psi.spellstat.bandwidth.desc": "启动式宽度或高度(最大值)",
"psi.bullet_type0": "标准",
"psi.bullet_type1": "抛射",
"psi.bullet_type2": "循环",
"psi.bullet_type3": "圈阵",
"psi.bullet_type4": "榴弹",
"psi.bullet_type5": "遥控",
"psi.bullet_type6": "地雷",
"psi.event.none": "(无指定事件)",
"psi.event.damage": "§b事件§7: 受伤",
"psi.event.tick": "§b事件§7: Tick",
"psi.event.jump": "§b事件§7: 跳跃",
"psi.event.low_light": "§b事件§7: 弱光",
"psi.event.underwater": "§b事件§7: 水下",
"psi.event.on_fire": "§b事件§7: 起火",
"psi.event.low_hp": "§b事件§7: **",
"psi.event.spell_detonate": "§b事件§7: 触发",
"psi.programmer_reference0": "§b键位绑定",
"psi.programmer_reference1": "删除块: §bDelete",
"psi.programmer_reference2": "清空网格: §b%1$s-Shift-Delete",
"psi.programmer_reference3": "移动网格: §b%1$s + 方向键",
"psi.programmer_reference4": "旋转网格: \u00a7b%1$s-Shift-左/右",
"psi.programmer_reference5": "垂直镜像: \u00a7b%1$s-Shift-下",
"psi.programmer_reference6": "复制/剪切/粘贴: §b%1$s-C/%1$s-X/%1$s-V",
"psi.programmer_reference7": "撤销/重做: §b%1$s-Z/%1$s-Y",
"psi.programmer_reference8": "打开面板/选择块: §bEnter",
"psi.programmer_reference9": "设定参数: §b数字键 + 方向键",
"psi.programmer_reference10": "设定注释: §b%1$s-D",
"psi.programmer_reference11": "切换焦点: §bTab",
"psi.programmer_reference12": "显示提示文本: §bAlt",
"psi.programmer_reference13": "移动光标: §b方向键",
"psi.programmer_reference14": "上传到Imgur: §b%1$s-Shift-Alt-G",
"psi.programmer_reference15": "分享至Reddit: §b%1$s-Shift-Alt-R",
"psi.programmer_reference16": "",
"psi.programmer_reference17": "§b搜索词",
"psi.programmer_reference18": "接收类型: §bin:(类型)",
"psi.programmer_reference19": "输出类型: §bout:(类型)",
"psi.programmer_reference20": "开头词: §b(名称)_",
"psi.programmer_reference21": "结尾词: §b_(名称)",
"psi.programmer_reference22": "从Mod: \u00a7b@(name)",
"psi.spellpiece.selector_caster": "选择符: 施法者",
"psi.spellpiece.selector_caster.desc": "选择展开术式的人",
"psi.spellpiece.selector_focal_point": "选择符: 焦点",
"psi.spellpiece.selector_focal_point.desc": "选择该术式的焦点实体",
"psi.spellpiece.selector_nearby_items": "选择符: 附近物品",
"psi.spellpiece.selector_nearby_items.desc": "选择指定位置附近的物品",
"psi.spellpiece.selector_nearby_living": "选择符: 附近生物",
"psi.spellpiece.selector_nearby_living.desc": "选择指定位置附近的生物",
"psi.spellpiece.selector_nearby_enemies": "选择符: 附近敌人",
"psi.spellpiece.selector_nearby_enemies.desc": "选择指定位置附近的敌人",
"psi.spellpiece.selector_nearby_animals": "选择符: 附近动物",
"psi.spellpiece.selector_nearby_animals.desc": "选择指定位置附近的动物",
"psi.spellpiece.selector_nearby_projectiles": "选择符: 附近投射物",
"psi.spellpiece.selector_nearby_projectiles.desc": "选择指定位置附近的投射物",
"psi.spellpiece.selector_nearby_smeltables": "选择符: 附近可熔物",
"psi.spellpiece.selector_nearby_smeltables.desc": "选择指定位置附近的可熔炼物品",
"psi.spellpiece.selector_loopcast_index": "选择符: 循环施法指针",
"psi.spellpiece.selector_loopcast_index.desc": "选择循环型术式的执行完成数",
"psi.spellpiece.selector_block_broken": "选择符: 破坏方块",
"psi.spellpiece.selector_block_broken.desc": "选择被破坏的方块(工具用)",
"psi.spellpiece.selector_block_side_broken": "选择符: 破坏方块侧",
"psi.spellpiece.selector_block_side_broken.desc": "选择方块被破坏的一侧(工具用)",
"psi.spellpiece.selector_attack_target": "选择符: 攻击目标",
"psi.spellpiece.selector_attack_target.desc": "选择被攻击的实体",
"psi.spellpiece.selector_sneak_status": "选择符: 潜行状态",
"psi.spellpiece.selector_sneak_status.desc": "施法者潜行时选择(未潜行为1, 潜行时为0)",
"psi.spellpiece.selector_time": "选择符: 时间",
"psi.spellpiece.selector_time.desc": "选择CAD的内部时间(以tick计)",
"psi.spellpiece.selector_attacker": "选择符: 攻击者",
"psi.spellpiece.selector_attacker.desc": "选择攻击施法者的实体",
"psi.spellpiece.selector_damage_taken": "选择符: 承受伤害",
"psi.spellpiece.selector_damage_taken.desc": "选择施法者承受的伤害值",
"psi.spellpiece.selector_ruler_vector": "选择符:测量向量",
"psi.spellpiece.selector_ruler_vector.desc": "选择向量尺界定的向量",
"psi.spellpiece.selector_item_presence": "选择符: 物品存在",
"psi.spellpiece.selector_item_presence.desc": "选择物品栏中一叠物品的数量",
"psi.spellpiece.selector_block_presence": "选择符: 方块存在",
"psi.spellpiece.selector_block_presence.desc": "选择一个方块的存在及其固态",
"psi.spellpiece.selector_saved_vector": "选择符: 储存向量",
"psi.spellpiece.selector_saved_vector.desc": "从CAD内存中选取一个储存的向量",
"psi.spellpiece.selector_eidos_changelog": "选择符: 时空变更记录",
"psi.spellpiece.selector_eidos_changelog.desc": "从时空变更记录中选取一个位置",
"psi.spellpiece.selector_nearby_charges": "选择符: 遥控子弹数",
"psi.spellpiece.selector_nearby_charges.desc": "选择在给定位置附近的遥控子弹数",
"psi.spellpiece.selector_nearby_players": "选择符: 附近玩家",
"psi.spellpiece.selector_nearby_players.desc": "选择指定位置附近的玩家",
"psi.spellpiece.selector_nearby_vehicles": "选择符: 附近可骑乘实体",
"psi.spellpiece.selector_nearby_vehicles.desc": "选择在给定位置附近可骑乘的实体",
"psi.spellpiece.selector_nearby_falling_blocks": "选择符: 附近下落方块",
"psi.spellpiece.selector_nearby_falling_blocks.desc": "选择在给定位置附近下落的方块",
"psi.spellpiece.selector_nearby_glowing": "选择符: 发光",
"psi.spellpiece.selector_nearby_glowing.desc": "选择在给定位置附近发光的实体",
"psi.spellpiece.selector_caster_energy": "选择符: 施法者能量",
"psi.spellpiece.selector_caster_energy.desc": "选择施法者的Psi能量水平",
"psi.spellpiece.selector_caster_battery": "选择符: 施法者电池",
"psi.spellpiece.selector_caster_battery.desc": "选择施法者的CAD电池水平",
"psi.spellpiece.selector_sucession_counter": "选择符: 执行次数",
"psi.spellpiece.selector_sucession_counter.desc": "选择一个法术在这个盔甲上执行的次数",
"psi.spellpiece.selector_is_elytra_flying": "选择符: 鞘翅",
"psi.spellpiece.selector_is_elytra_flying.desc": "如果施法者已经装备鞘翅，返回1",
"psi.spellpiece.selector_transmission": "选择符: 最后信息",
"psi.spellpiece.selector_transmission.desc": "获取此CAD在给定通道中接收的最后一条消息",
"psi.spellpiece.selector_item_count": "选择符: 物品数",
"psi.spellpiece.selector_item_count.desc": "计算你背包中选中物品的数目数",
"psi.spellpiece.operator_sum": "运算符: 加法",
"psi.spellpiece.operator_sum.desc": "A + B (+ C)",
"psi.spellpiece.operator_subtract": "运算符: 减法",
"psi.spellpiece.operator_subtract.desc": "A - B (- C)",
"psi.spellpiece.operator_multiply": "运算符: 乘法",
"psi.spellpiece.operator_multiply.desc": "A * B (* C)",
"psi.spellpiece.operator_divide": "运算符: 除法",
"psi.spellpiece.operator_divide.desc": "A / B",
"psi.spellpiece.operator_absolute": "运算符: 绝对值",
"psi.spellpiece.operator_absolute.desc": "计算一个数的绝对值",
"psi.spellpiece.operator_inverse": "运算符: 倒数",
"psi.spellpiece.operator_inverse.desc": "计算一个数的倒数",
"psi.spellpiece.operator_modulus": "运算符: 求余",
"psi.spellpiece.operator_modulus.desc": "A % B (取整)",
"psi.spellpiece.operator_integer_divide": "运算符: 整除",
"psi.spellpiece.operator_integer_divide.desc": "A / B (取整)",
"psi.spellpiece.operator_random": "运算符: 随机",
"psi.spellpiece.operator_random.desc": "在0与指定数值间随机取值(唯一)",
"psi.spellpiece.operator_sin": "运算符: 正弦",
"psi.spellpiece.operator_sin.desc": "sin(A)",
"psi.spellpiece.operator_cos": "运算符: 余弦",
"psi.spellpiece.operator_cos.desc": "cos(A)",
"psi.spellpiece.operator_asin": "运算符: 反正弦",
"psi.spellpiece.operator_asin.desc": "asin(A)",
"psi.spellpiece.operator_acos": "运算符: 反余弦",
"psi.spellpiece.operator_acos.desc": "acos(A)",
"psi.spellpiece.operator_max": "运算符: 最大",
"psi.spellpiece.operator_max.desc": "获取输入值中的最大值",
"psi.spellpiece.operator_min": "运算符: 最小",
"psi.spellpiece.operator_min.desc": "获取输入值中的最小值",
"psi.spellpiece.operator_square": "运算符: 平方",
"psi.spellpiece.operator_square.desc": "A^2",
"psi.spellpiece.operator_cube": "运算符: 立方",
"psi.spellpiece.operator_cube.desc": "A^3",
"psi.spellpiece.operator_power": "运算符: 幂",
"psi.spellpiece.operator_power.desc": "A^B",
"psi.spellpiece.operator_square_root": "运算符: 平方根",
"psi.spellpiece.operator_square_root.desc": "sqrt(A)",
"psi.spellpiece.operator_log": "运算符: 对数",
"psi.spellpiece.operator_log.desc": "log(A)或logB(A)",
"psi.spellpiece.operator_ceiling": "运算符: 向上圆整",
"psi.spellpiece.operator_ceiling.desc": "将一个数向上圆整",
"psi.spellpiece.operator_floor": "运算符: 向下圆整",
"psi.spellpiece.operator_floor.desc": "将一个数向下圆整",
"psi.spellpiece.operator_round": "运算符: 四舍五入",
"psi.spellpiece.operator_round.desc": "将一个数四舍五入取整",
"psi.spellpiece.operator_entity_position": "运算符: 实体位置",
"psi.spellpiece.operator_entity_position.desc": "获取一个实体的位置",
"psi.spellpiece.operator_entity_look": "运算符: 实体视线",
"psi.spellpiece.operator_entity_look.desc": "获取一个实体的视线向量",
"psi.spellpiece.operator_entity_motion": "运算符: 实体运动",
"psi.spellpiece.operator_entity_motion.desc": "获取一个实体的运动向量",
"psi.spellpiece.operator_entity_axial_look": "运算符: 实体轴向视线",
"psi.spellpiece.operator_entity_axial_look.desc": "获取一个实体的视线向量, 与某一轴对齐",
"psi.spellpiece.operator_focused_entity": "运算符: 聚焦实体",
"psi.spellpiece.operator_focused_entity.desc": "获取指定实体所看的实体",
"psi.spellpiece.operator_vector_raycast": "运算符: 向量追踪",
"psi.spellpiece.operator_vector_raycast.desc": "获取一个向量路径定位的方位(最大范围32)",
"psi.spellpiece.operator_vector_raycast_axis": "运算符: 向量轴向追踪",
"psi.spellpiece.operator_vector_raycast_axis.desc": "获取一个向量路径定位的侧面相对于所在方块的位置(最大范围32)",
"psi.spellpiece.operator_vector_sum": "运算符: 向量和",
"psi.spellpiece.operator_vector_sum.desc": "A + B (+ C)",
"psi.spellpiece.operator_vector_subtract": "运算符: 向量差",
"psi.spellpiece.operator_vector_subtract.desc": "A - B (- C)",
"psi.spellpiece.operator_vector_multiply": "运算符: 向量乘",
"psi.spellpiece.operator_vector_multiply.desc": "将向量乘一数值",
"psi.spellpiece.operator_vector_divide": "运算符: 向量除",
"psi.spellpiece.operator_vector_divide.desc": "A / B",
"psi.spellpiece.operator_vector_cross_product": "运算符: 向量叉乘",
"psi.spellpiece.operator_vector_cross_product.desc": "A x B",
"psi.spellpiece.operator_vector_normalize": "运算符: 单位向量",
"psi.spellpiece.operator_vector_normalize.desc": "单位化一个向量使其模为1",
"psi.spellpiece.operator_vector_negate": "运算符: 反向量",
"psi.spellpiece.operator_vector_negate.desc": "求出一反向量",
"psi.spellpiece.operator_vector_magnitude": "运算符: 向量模",
"psi.spellpiece.operator_vector_magnitude.desc": "获取一个向量的模",
"psi.spellpiece.operator_vector_construct": "运算符: 向量构造",
"psi.spellpiece.operator_vector_construct.desc": "通过XYZ的参数构造一个向量",
"psi.spellpiece.operator_vector_extract_x": "运算符: 向量提取X",
"psi.spellpiece.operator_vector_extract_x.desc": "从一个向量中提取X坐标值",
"psi.spellpiece.operator_vector_extract_y": "运算符: 向量提取Y",
"psi.spellpiece.operator_vector_extract_y.desc": "从一个向量中提取Y坐标值",
"psi.spellpiece.operator_vector_extract_z": "运算符: 向量提取Z",
"psi.spellpiece.operator_vector_extract_z.desc": "从一个向量中提取Z坐标值",
"psi.spellpiece.operator_vector_project": "运算符: 向量投影",
"psi.spellpiece.operator_vector_project.desc": "将向量A投影到向量B",
"psi.spellpiece.operator_vector_dot_product": "运算符: 向量点乘",
"psi.spellpiece.operator_vector_dot_product.desc": "A . B",
"psi.spellpiece.operator_closest_to_point": "运算符: 离点最近",
"psi.spellpiece.operator_closest_to_point.desc": "从一个列表中获取距离某一点最近的实体",
"psi.spellpiece.operator_random_entity": "运算符: 随机实体",
"psi.spellpiece.operator_random_entity.desc": "从一个列表中随机获取一实体",
"psi.spellpiece.operator_list_add": "运算符: 加入列表",
"psi.spellpiece.operator_list_add.desc": "将指定实体加入列表",
"psi.spellpiece.operator_list_remove": "运算符: 移出列表",
"psi.spellpiece.operator_list_remove.desc": "将指定实体移出列表",
"psi.spellpiece.operator_planar_normal_vector": "运算符: 平面法向量",
"psi.spellpiece.operator_planar_normal_vector.desc": "创建一个垂直于给定轴向向量的向量。相当于围绕<1,1,1>旋转2π/3",
"psi.spellpiece.operator_vector_rotate": "运算符: 旋转矢量",
"psi.spellpiece.operator_vector_rotate.desc": "绕轴旋转矢量",
"psi.spellpiece.operator_gamma_function": "运算符: 伽马函数",
"psi.spellpiece.operator_gamma_function.desc": "Γ(x), 等于 (x-1)!",
"psi.spellpiece.operator_list_size": "运算符: 列表大小",
"psi.spellpiece.operator_list_size.desc": "获取列表中实体的数量",
"psi.spellpiece.operator_list_union": "运算符: 列表并",
"psi.spellpiece.operator_list_union.desc": "建造一个包含其他列表所有项的列表",
"psi.spellpiece.operator_list_intersection": "运算符: 列表交",
"psi.spellpiece.operator_list_intersection.desc": "建造一个包含两个列表**有项的列表",
"psi.spellpiece.operator_list_exclusion": "运算符: 列表排除",
"psi.spellpiece.operator_list_exclusion.desc": "建造一个包含第一个列表有但第二个列表没有项的列表",
"psi.spellpiece.operator_list_index": "选择符: 索引",
"psi.spellpiece.operator_list_index.desc": "选择实体列表中给定索引的实体",
"psi.spellpiece.operator_root": "运算符: 根",
"psi.spellpiece.operator_root.desc": "取这个数的n次方根",
"psi.spellpiece.operator_extract_sign": "运算符: 符号",
"psi.spellpiece.operator_extract_sign.desc": "从输入中提取符号",
"psi.spellpiece.operator_vector_extract_sign": "运算符: 向量",
"psi.spellpiece.operator_vector_extract_sign.desc": "返回一个新向量，带有向量每个分量对应的符号",
"psi.spellpiece.operator_closest_to_line": "运算符: 离线段最近",
"psi.spellpiece.operator_closest_to_line.desc": "选择离线段最近的实体",
"psi.spellpiece.operator_entity_health": "运算符: 实体生命",
"psi.spellpiece.operator_entity_health.desc": "获取实体的当前生命百分比",
"psi.spellpiece.operator_vector_absolute": "运算符: 向量绝对值",
"psi.spellpiece.operator_vector_absolute.desc": "对向量每个值取绝对值并返回一个新的向量",
"psi.spellpiece.operator_entity_raycast": "运算符: 光线投射实体",
"psi.spellpiece.operator_entity_raycast.desc": "从给定的位置进行光线投射，并返回它找到的第一个实体",
"psi.spellpiece.operator_block_light": "运算符: 方块亮度",
"psi.spellpiece.operator_block_light.desc": "获取方块的亮度",
"psi.spellpiece.operator_block_hardness.desc": "获取方块的硬度",
"psi.spellpiece.operator_block_hardness": "运算符: 方块硬度",
"psi.spellpiece.operator_block_comparator_strength": "运算符: 比较器",
"psi.spellpiece.operator_block_comparator_strength.desc": "获取方块具有的比较器强度",
"psi.spellpiece.operator_block_side_solidity": "运算符: 方块侧面实心",
"psi.spellpiece.operator_block_side_solidity.desc": "获取方块的侧面是否是实心的",
"psi.spellpiece.operator_block_mining_level": "运算符: 方块挖掘等级",
"psi.spellpiece.operator_block_mining_level.desc": "获取指定位置方块的挖掘等级",
"psi.spellpiece.operator_vector_piecewise_maximum": "运算符: 向量分量最大",
"psi.spellpiece.operator_vector_piecewise_maximum.desc": "用输入向量的每个分量中最大的构造一个向量",
"psi.spellpiece.operator_vector_piecewise_minimum": "运算符: 向量分量最小",
"psi.spellpiece.operator_vector_piecewise_minimum.desc": "用输入向量的每个分量中最小的构造一个向量",
"psi.spellpiece.operator_entity_height": "运算符: 实体高度",
"psi.spellpiece.operator_entity_height.desc": "获取实体的高度",
"psi.spellpiece.constant_number": "常量: 数字",
"psi.spellpiece.constant_number.desc": "选择然后输入设定值",
"psi.spellpiece.constant_pi": "常量: Pi",
"psi.spellpiece.constant_pi.desc": "返回圆周率Pi的值",
"psi.spellpiece.constant_e": "常量: e",
"psi.spellpiece.constant_e.desc": "返回自然对数底数e的值",
"psi.spellpiece.constant_tau": "常量: τ",
"psi.spellpiece.constant_tau.desc": "返回τ的值(2pi)",
"psi.spellpiece.constant_wrapper": "常量: 封装",
"psi.spellpiece.constant_wrapper.desc": "为要计算的常量而准备的封装",
"psi.spellpiece.connector": "连接符",
"psi.spellpiece.connector.desc": "起连接程序的作用",
"psi.spellpiece.cross_connector": "交叉连接符",
"psi.spellpiece.cross_connector.desc": "可连接两路",
"psi.spellpiece.error_suppressor": "错误消除符",
"psi.spellpiece.error_suppressor.desc": "消除魔法式产生的错误",
"psi.spellpiece.error_catch": "错误捕捉",
"psi.spellpiece.error_catch.desc": "用另一个值替换错误",
"psi.spellpiece.trick_debug": "启动式: 调试",
"psi.spellpiece.trick_debug.desc": "测试用. 打印输出目标",
"psi.spellpiece.trick_delay": "启动式: 休眠",
"psi.spellpiece.trick_delay.desc": "在一段ticks的时间内延迟术式",
"psi.spellpiece.trick_die": "启动式: 终结",
"psi.spellpiece.trick_die.desc": "如果目标处于]-1, 1[内则停止术式的执行",
"psi.spellpiece.trick_evaluate": "启动式: 求值",
"psi.spellpiece.trick_evaluate.desc": "求出一个值. 什么也不做",
"psi.spellpiece.trick_add_motion": "启动式: 附加运动",
"psi.spellpiece.trick_add_motion.desc": "给目标实体附加运动",
"psi.spellpiece.trick_explode": "启动式: 爆炸",
"psi.spellpiece.trick_explode.desc": "引发爆炸",
"psi.spellpiece.trick_break_block": "启动式: 破坏方块",
"psi.spellpiece.trick_break_block.desc": "破坏一个方块",
"psi.spellpiece.trick_break_in_sequence": "启动式: 破坏方块序列",
"psi.spellpiece.trick_break_in_sequence.desc": "根据定义的向量破坏一系列的方块",
"psi.spellpiece.trick_place_block": "启动式: 放置方块",
"psi.spellpiece.trick_place_block.desc": "放置一个方块 (物品栏中仅次于CAD右侧的方块)",
"psi.spellpiece.trick_place_in_sequence": "启动式: 放置方块序列",
"psi.spellpiece.trick_place_in_sequence.desc": "根据定义的向量放置一系列的方块",
"psi.spellpiece.trick_infusion": "启动式: 聚变",
"psi.spellpiece.trick_infusion.desc": "将金聚变为Psi金属",
"psi.spellpiece.trick_blink": "启动式: 闪现",
"psi.spellpiece.trick_blink.desc": "向前方闪现",
"psi.spellpiece.trick_mass_blink": "启动式: 群体闪现",
"psi.spellpiece.trick_mass_blink.desc": "带领所有人向前闪现",
"psi.spellpiece.trick_mass_add_motion": "启动式: 群体运动",
"psi.spellpiece.trick_mass_add_motion.desc": "给指定实体列表内的所有实体附加运动",
"psi.spellpiece.trick_mass_exodus": "启动式: 群体移动",
"psi.spellpiece.trick_mass_exodus.desc": "将指定实体列表内所有实体移动到目标位置",
"psi.spellpiece.trick_move_block": "启动式: 移动方块",
"psi.spellpiece.trick_move_block.desc": "将一方块沿目标(标准)向量轴移动",
"psi.spellpiece.trick_move_block_sequence": "启动式: 移动方块序列",
"psi.spellpiece.trick_move_block_sequence.desc": "沿着给定的单位轴向量移动一组块",
"psi.spellpiece.trick_collapse_block": "启动式: 方块崩塌",
"psi.spellpiece.trick_collapse_block.desc": "使一方块像沙子般下落",
"psi.spellpiece.trick_smite": "启动式: 雷击",
"psi.spellpiece.trick_smite.desc": "在指定点召唤闪电落下",
"psi.spellpiece.trick_blaze": "启动式: 烈焰",
"psi.spellpiece.trick_blaze.desc": "在指定点制造火焰",
"psi.spellpiece.trick_torrent": "启动式: 洪流",
"psi.spellpiece.trick_torrent.desc": "在指定点制造流水",
"psi.spellpiece.trick_overgrow": "启动式: 生长",
"psi.spellpiece.trick_overgrow.desc": "催生指定点的方块",
"psi.spellpiece.trick_greater_infusion": "启动式: 高级聚变",
"psi.spellpiece.trick_greater_infusion.desc": "将钻石聚变为Psi宝石",
"psi.spellpiece.trick_ebony_ivory": "启动式: 阴阳变化",
"psi.spellpiece.trick_ebony_ivory.desc": "聚变煤炭和石英. 必须在末地进行",
"psi.spellpiece.trick_speed": "启动式: 速度",
"psi.spellpiece.trick_speed.desc": "赋予速度效果",
"psi.spellpiece.trick_haste": "启动式: 急迫",
"psi.spellpiece.trick_haste.desc": "赋予急迫效果",
"psi.spellpiece.trick_strength": "启动式: 力量",
"psi.spellpiece.trick_strength.desc": "赋予力量效果",
"psi.spellpiece.trick_jump_boost": "启动式: 跳跃提升",
"psi.spellpiece.trick_jump_boost.desc": "赋予跳跃提升效果",
"psi.spellpiece.trick_water_breathing": "启动式: 水肺",
"psi.spellpiece.trick_water_breathing.desc": "赋予水下呼吸效果",
"psi.spellpiece.trick_fire_resistance": "启动式: 抗火",
"psi.spellpiece.trick_fire_resistance.desc": "赋予抗火效果",
"psi.spellpiece.trick_invisibility": "启动式: 隐形",
"psi.spellpiece.trick_invisibility.desc": "赋予隐身效果",
"psi.spellpiece.trick_regeneration": "启动式: 再生",
"psi.spellpiece.trick_regeneration.desc": "赋予再生效果",
"psi.spellpiece.trick_resistance": "启动式: 抗性",
"psi.spellpiece.trick_resistance.desc": "赋予抗性效果",
"psi.spellpiece.trick_slowness": "启动式: 缓慢",
"psi.spellpiece.trick_slowness.desc": "赋予缓慢效果",
"psi.spellpiece.trick_weakness": "启动式: 虚弱",
"psi.spellpiece.trick_weakness.desc": "赋予虚弱效果",
"psi.spellpiece.trick_wither": "启动式: 凋零",
"psi.spellpiece.trick_wither.desc": "赋予凋零效果",
"psi.spellpiece.trick_ignite": "启动式: 引燃",
"psi.spellpiece.trick_ignite.desc": "使一个实体燃烧起来",
"psi.spellpiece.trick_eidos_anchor": "启动式: 时空之锚",
"psi.spellpiece.trick_eidos_anchor.desc": "在指定时间后将施法者送回当前位置",
"psi.spellpiece.trick_eidos_reversal": "启动式: 时空逆流",
"psi.spellpiece.trick_eidos_reversal.desc": "让施法者时光倒流",
"psi.spellpiece.trick_smelt_item": "启动式: 熔炼物品",
"psi.spellpiece.trick_smelt_item.desc": "将一个物品实体熔炼为对应的产物",
"psi.spellpiece.trick_smelt_block": "启动式: 熔炼方块",
"psi.spellpiece.trick_smelt_block.desc": "将一个方块熔炼为对应的产物",
"psi.spellpiece.trick_conjure_block": "启动式: 构筑方块",
"psi.spellpiece.trick_conjure_block.desc": "在指定位置构筑一个方块",
"psi.spellpiece.trick_conjure_light": "启动式: 构筑光线",
"psi.spellpiece.trick_conjure_light.desc": "在指定位置构筑一团亮光",
"psi.spellpiece.trick_conjure_block_sequence": "启动式: 构筑方块序列",
"psi.spellpiece.trick_conjure_block_sequence.desc": "构筑一系列的方块",
"psi.spellpiece.trick_switch_target_slot": "启动式: 切换焦点槽位",
"psi.spellpiece.trick_switch_target_slot.desc": "改变此术式的焦点槽位",
"psi.spellpiece.trick_save_vector": "启动式: 储存向量",
"psi.spellpiece.trick_save_vector.desc": "将一个向量存入CAD的内存中",
"psi.spellpiece.trick_play_sound": "启动式: 播放音符",
"psi.spellpiece.trick_play_sound.desc": "播放一个音符盒的声音",
"psi.spellpiece.trick_break_loop": "启动式: 中断循环",
"psi.spellpiece.trick_break_loop.desc": "如果目标在(- 1,1)内，则停止循环",
"psi.spellpiece.trick_detonate": "启动式: 引爆",
"psi.spellpiece.trick_detonate.desc": "引发距离焦点32个街区内的所有法术",
"psi.spellpiece.trick_till": "启动式: 犁地",
"psi.spellpiece.trick_till.desc": "犁一个方块",
"psi.spellpiece.trick_till_sequence": "启动式: 犁方块序列",
"psi.spellpiece.trick_till_sequence.desc": "沿给定向量犁一组方块",
"psi.spellpiece.trick_broadcast": "启动式: 广播",
"psi.spellpiece.trick_broadcast.desc": "将给定频道中的一个数字广播给附近的CAD",
"psi.spellpiece.trick_change_slot": "启动式: Slot Change (Inventory)",
"psi.spellpiece.trick_change_slot.desc": "Changes the building slot to one of the 36 inventory slots.",
"psi.spellpiece.trick_smelt_block_sequence": "启动式: 冶炼方块序列",
"psi.spellpiece.trick_smelt_block_sequence.desc": "冶炼给定的位置的给定方向的方块",
"psi.spellpiece.trick_collapse_block_sequence": "启动式: 方块序列崩塌",
"psi.spellpiece.trick_collapse_block_sequence.desc": "使一系列方块像沙子般下落",
"psi.spellpiece.trick_debug_spamless": "启动式: 频道调试",
"psi.spellpiece.trick_debug_spamless.desc": "打印目标，用数字替换以前的任何打印",
"psi.spellpiece.trick_night_vision": "启动式: 夜视",
"psi.spellpiece.trick_night_vision.desc": "应用夜视效果",
"psi.spellpiece.trick_particle_trail": "启动式: 粒子轨迹",
"psi.spellpiece.trick_particle_trail.desc": "沿着射线从一个位置产生一个粒子轨迹",
"psi.spellpiece.trick_spin_chamber": "启动式: 换弹",
"psi.spellpeice.trick_spin_chamber.desc": "根据输入的符号选择下一个或前一个子弹",
"psi.spellpiece.trick_russian_roulette": "启动式: 俄式**",
"psi.spellpiece.trick_russian_roulette.desc": "随机选择一颗子弹",
"psi.spellparam.target": "目标",
"psi.spellparam.number": "数字",
"psi.spellparam.root": "根",
"psi.spellparam.list1": "列表A",
"psi.spellparam.list2": "列表B",
"psi.spellparam.list": "列表",
"psi.spellparam.from1": "从",
"psi.spellparam.from2": "从",
"psi.spellparam.to1": "到",
"psi.spellparam.to2": "到",
"psi.spellparam.toggle": "开关",
"psi.spellparam.number1": "数字A",
"psi.spellparam.number2": "数字B",
"psi.spellparam.number3": "数字C",
"psi.spellparam.number4": "数字D",
"psi.spellparam.vector1": "向量A",
"psi.spellparam.vector2": "向量B",
"psi.spellparam.vector3": "向量C",
"psi.spellparam.vector4": "向量D",
"psi.spellparam.position": "位置",
"psi.spellparam.ray": "路径",
"psi.spellparam.max": "最大",
"psi.spellparam.min": "最小",
"psi.spellparam.power": "级别",
"psi.spellparam.direction": "方向",
"psi.spellparam.speed": "速度",
"psi.spellparam.x": "X",
"psi.spellparam.y": "Y",
"psi.spellparam.z": "Z",
"psi.spellparam.radius": "半径",
"psi.spellparam.distance": "距离",
"psi.spellparam.time": "时间",
"psi.spellparam.constant": "常量",
"psi.spellparam.shift": "移位",
"psi.spellparam.slot": "槽位",
"psi.spellparam.base": "底",
"psi.spellparam.vector": "向量",
"psi.spellparam.axis": "轴",
"psi.spellparam.angle": "角",
"psi.spellparam.channel": "通道",
"psi.spellparam.instrument": "乐器",
"psi.spellparam.volume": "音量",
"psi.spellparam.pitch": "音高",
"psi.spellparam.mask": "模式",
"psi.spellparam.ray_end": "射线结束",
"psi.spellparam.ray_start": "射线开始",
"psi.spellparam.fallback": "备用",
"psi.datatype.void": "无",
"psi.datatype.any": "任意",
"psi.datatype.double": "数字",
"psi.datatype.integer": "数字",
"psi.datatype.number": "数字",
"psi.datatype.vector3": "向量",
"psi.datatype.entity": "实体",
"psi.datatype.living_entity": "实体 (Living)",
"psi.datatype.living_entity_base": "实体 (Living)",
"psi.datatype.player_entity": "实体 (Player, Living)",
"psi.datatype.entity_list_wrapper": "实体列表",
"psi.spellerror.nospell": "无编译中的魔法式",
"psi.spellerror.invalid_base": "错误: 不能解释2以下的基数",
"psi.spellerror.nthroot": "错误: 偶数根不能接受负数",
"psi.spellerror.noname": "魔法式未命名",
"psi.spellerror.notricks": "魔法式中缺少启动式",
"psi.spellerror.unsetparam": "所需参数尚未设定",
"psi.spellerror.nullparam": "指定的参数不能是一个空单元",
"psi.spellerror.invalidparam": "指定的参数无效",
"psi.spellerror.samesideparams": "两个及以上的参数共用了同一侧",
"psi.spellerror.loop": "死循环无法求解",
"psi.spellerror.nonpositivevalue": "指定的数字参数必须是一个正数",
"psi.spellerror.noninteger": "指定的数字参数必须是一个整数",
"psi.spellerror.nonpositiveinteger": "指定的数字参数必须是一个正整数",
"psi.spellerror.statoverflow": "魔法式溢值超出了最大合理整数",
"psi.spellerror.exclusiveparams": "设定了两个相互排斥的参数",
"psi.spellerror.position": "错误位置·: [%d, %d].",
"psi.spellerror.dividebyzero": "错误: 不能除以0.",
"psi.spellerror.nulltarget": "错误: 术式目标实体不存在.",
"psi.spellerror.nullvector": "错误: 术式运算向量不存在或无效.",
"psi.spellerror.outsideradius": "错误: 术式目标超出了32格半径范围.",
"psi.spellerror.outsidetrigdomain": "错误: 数值超出了反三角函数域.",
"psi.spellerror.bossimmune": "错误: 尝试对免疫实体或boss施展魔法式.",
"psi.spellerror.nocad": "错误: 施法者无CAD.",
"psi.spellerror.memoryoutofbounds": "错误: 内存访问出界.",
"psi.spellerror.lockedmemory": "错误: 内存槽位锁定.",
"psi.spellerror.immunetarget": "错误: 目标实体免疫或为boss.",
"psi.spellerror.negativenumber": "错误: 功能块中的目标数字不能为负数.",
"psi.spellerror.nonaxial": "错误: 矢量不能是非轴的",
"psi.spellerror.volume": "错误: 音量必须在[0,1]之间",
"psi.spellerror.instruments": "错误: 乐器值必须在[0,15]之间",
"psi.spellerror.pitch": "错误: 音高必须在[0,24]之间",
"psi.spellerror.out_of_bounds": "错误: 所提供的索引不在列表的范围内",
"psi.levelskip": "Psi发现了上一个世界的数据存档.<br>你想要加载这些数据吗?<br><br>如果选择是, 那么你的等级就会立即变为%d. 选择否的话, 这条信息不会再次出现.",
"psi.spellerror.armor": "错误: 选择器只在护甲施放时有效",
"psi.spellerror.no_message": "错误: CAD处没有收到广播信息",
"psi.spellerror.comparator": "错误: 比较器只能在4个基本方向进行测量",
"psi.spellerror.cad_casting_only": "错误: 这把戏一定是CAD耍的",
"command.psi.learn.usage": "/psi-learn <group> [player]",
"command.psi.learn.success": "Successfully taught %s %s",
"command.psi.learn.success.all": "Successfully taught %s all of Psi",
"command.psi.learn.should_not": "%s already knows %s",
"command.psi.learn.players": "%s isn't a player, only players can have Psi knowledge",
"command.psi.learn.console": "The console can't learn Psi. Try specifying a player! /psi-learn <group> [player]",
"command.psi.learn.not_a_group": "'%s' is not a valid Psi piece group",
"command.psi.learn.unknown": "This player has no Psi data. Report this to the mod author.",
"command.psi.unlearn.usage": "/psi-unlearn <group> [player]",
"command.psi.unlearn.success": "Successfully made %s forget %s",
"command.psi.unlearn.success.all": "Successfully made %s forget all of Psi",
"command.psi.unlearn.should_not": "%s doesn't know %s",
"command.psi.unlearn.players": "%s isn't a player, only players can have Psi knowledge",
"command.psi.unlearn.console": "The console can't learn Psi. Try specifying a player! /psi-unlearn <group> [player]",
"command.psi.unlearn.not_a_group": "'%s' is not a valid Psi piece group",
"command.psi.unlearn.unknown": "This player has no Psi data. Report this to the mod author.",
"psi.tutorial1": "Tutorial 1",
"psi.tutorial2": "Tutorial 2",
"psi.tutorial3": "Tutorial 3",
"psi.tutorial4": "Tutorial 4",
"psi.numbers_intro": "Numbers 101",
"psi.vectors_intro": "Vectors 101",
"psi.entities_intro": "Entities 101",
"psi.projectiles": "Alternative Casting",
"psi.block_works": "Blockworks",
"psi.infusion": "Psimetal Infusion",
"psi.movement": "Movement Advances",
"psi.loopcasting": "Loopcasting",
"psi.block_movement": "Block Movement",
"psi.elemental_arts": "Elemental Arts",
"psi.greater_infusion": "Greater Infusion",
"psi.tool_casting": "Tool Casting",
"psi.positive_effects": "Positive Effects",
"psi.negative_effects": "Negative Effects",
"psi.exosuit_casting": "Exosuit Casting",
"psi.trignometry": "Trigonometry",
"psi.smeltery": "Smeltery",
"psi.flow_control": "Flow Control",
"psi.block_conjuration": "Block Conjuration",
"psi.eidos_ceversal": "Eidos Manipulation",
"psi.detection_dynamics": "Detection & Focus",
"psi.memory_management": "Memory Management",
"psi.secondary_operators": "Secondary Operators",
"psi.misc_tricks": "Misc Tricks",
"psi.list_operations": "List Operations",
"psi.fake_level_psidust": "Psidust Infusion",
"jei.psi.category.trick": "Spell Infusion",
"jei.psi.spell_copy": "Copies spell",
"psi.subtitle.book": "Sweet Alexum plays in the distance",
"_comment": "Book stuff",
"advancement.psi:iron_cad_pickup": "Sweet Bod",
"advancement.psi:iron_cad_pickup.desc": "Craft an Iron CAD Assembly",
"advancement.psi:gold_assembly_pickup": "Worth Its Weight In Gold",
"advancement.psi:gold_assembly_pickup.desc": "Craft a Gold CAD Assembly",
"advancement.psi:psimetal_assembly_pickup": "Psightly Better",
"advancement.psi:psimetal_assembly_pickup.desc": "Craft a Psimetal CAD Assembly",
"advancement.psi:ebony_assembly_pickup": "Strong and Thick",
"advancement.psi:ebony_assembly_pickup.desc": "Craft an Ebony CAD Assembly",
"advancement.psi:ivory_assembly_pickup": "Sleeker and Sexier",
"advancement.psi:ivory_assembly_pickup.desc": "Craft an Ivory CAD Assembly",
"advancement.psi:psidust": "...Uncraftable?",
"advancement.psi:psidust.desc": "Craft your first piece of Psidust",
"advancement.psi:psimetal_pickup": "The Alloy Of Awe",
"advancement.psi:psimetal_pickup.desc": "Infuse your first piece of Psimetal",
"advancement.psi:psigem_pickup": "Thought Crystal",
"advancement.psi:psigem_pickup.desc": "Infuse your first Psigem out of diamonds",
"advancement.psi:ebony_pickup": "High Value",
"advancement.psi:ebony_pickup.desc": "Infuse your first Ebony substance out of Coal",
"advancement.psi:ivory_pickup": "Differently Valued",
"advancement.psi:ivory_pickup.desc": "Infuse your first Ivory substance out of Quartz",
"advancement.psi:encyclopaedia_psionica": "Put It On My Tablet",
"advancement.psi:encyclopaedia_psionica.desc": "制作《Psi百科全书》--Psi的指南",
"psi.book.subtitle": "Spellslinging 101",
"psi.book.name": "Psi百科全书",
"psi.book.landing_text": "$(thing)Psi$(0)是一个关于创造$(thing)术式$(0)的mod，它的限制只能由你自己的创造力来定义。这本书包含了你成为法术专家所需要的所有知识。$(p)(这本书正在编写中。您可以在遗留条目部分下找到旧的教程条目。)",
"psi.book.category.basics": "基础",
"psi.book.category.basics.desc": "如果你是$(thing)Psi$(0)的新手，我建议你仔细阅读这里的每一个条目。所有这些都包含重要的信息。",
"psi.book.entry.introduction": "介绍",
"psi.book.page.introduction.0": "欢迎来到全宇宙最好的术式编程型魔法科技mod——$(thing)Psi$(0)的世界。$(p)$(thing)Psi$(0)是一个mod，它可以在你周围的世界中创造和施放你想要的咒语。(灵感来自于名为Mahouka的系列)。要开始你的旅程成为一个法术法师，你首先需要一些$(l:components/psidust)$(item)Psi粉末$(0)$(/l)——然而，一个人不只是简单地制作东西。",
"psi.book.page.introduction.1": "相反，通过制作一个$(l:basics/cad_assembler)$(item)CAD装配器$(0)$(/l)和一个$(l:components/assembly#iron)$(item)铁质CAD机体$(0)$(/l)来开始。$(p)放置$(l:basics/cad_assembler)$(item)CAD装配器$(0)$(/l)，打开它，并插入$(l:components/assembly#iron)$(item)铁质CAD机体$(0)$(/l)，以构建一个非常简单的$(thing)术式辅助演算机$(0)，简称$(thing)CAD$(0)。$(p)然后，扔一些$(item)红石粉$(0)在地上，用$(thing)CAD$(0)指向红石粉，射击以铸造一些$(l:components/psidust)$(item)Psi粉末$(0)$(/l)。",
"psi.book.entry.cadAssembler": "CAD装配器",
"psi.book.page.cadAssembler.0": "$(item)CAD装配器$(0)是$(thing)Psi$(0)的核心，具有两个基本功能。$(p)首先，它从它的组成部分组装一个$(thing)CAD$(0)。其次，它可以将$(o)非空$()的$(l:items/spell_bullet)$(thing)术式子弹$(0)$(/l)装入$(thing)CAD$(0)或其他装子弹的东西，比如$(l:items/tools)$(thing)Psi工具$(0)$(/l)。",
"psi.book.page.cadAssembler.1": "CAD装配器合成表",
"psi.book.page.cadAssembler.2": "可施法的最简CAD",
"psi.book.page.cadAssembler.3": "$(thing)CAD$(0)由多达五个组件构成;最简单的$(thing)CAD$(0)只使用一个组件----一个$(l:components/assembly)$(thing)CAD机体$(0)$(/l)，尽管这只对制作$(l:components/psidust)$(item)Psi尘$(0)$(/l)有用。$(p)能够施放$(thing)术式$(0)的$(thing)CAD$(0)也只需要还一个$(l:components/core)$(thing)CAD核心$(0)$(/l)和$(l:components/socket)$(thing)CAD弹夹$(0)$(/l)。$(p)添加$(l:components/battery)$(thing)CAD电池$(0)$(/l)会略微增加用户的最大$(thing)Psi能量$(0)，添加$(l:components/colorizer)$(thing)着色器$(0)$(/l)会改变$(thing)法术$(0)的颜色，这纯粹是为了美观。",
"psi.book.page.cadAssembler.4": "一旦创建了$(thing)CAD$(0)，就可以将其放置在$(item)CAD装配器$(0)的最左边面板中。$(p)放置后，下面的槽会解锁;$(l:items/spell_bullet)$(thing)术式子弹$(0)$(/l)可以放置在这些槽中，以加载到$(thing)CAD$(0)中。$(p)在$(l:items/spell_bullet)$(thing)子弹$(0)$(/l)放入、$(thing)CAD$(0)被拿出并手持后，按下$(thing)Psi主键$(0) ($(k:psimisc.keybind)) 时，$(l:items/spell_bullet)$(thing)子弹$(0)$(/l)的$(thing)术式$(0)将显示在HUD上，准备被选择和施放。",
"psi.book.page.cadAssembler.5": "装有一颗子弹的CAD",
"psi.book.entry.spellProgrammer": "术式编写台",
"psi.book.page.spellProgrammer.0": "If the $(l:basics/cad_assembler)$(item)CAD Assembler$(0)$(/l) is the heart of $(thing)Psi$(0), then the $(item)Spell Programmer$(0) is the brains of the mod. It's where $(thing)Spells$(0) are written and compiled, and eventually copied into $(l:items/spell_bullet)$(thing)Spell Bullets$(0)$(/l) to be cast.$(p)When placed and opened ($(k:use)), it displays a large 9x9 grid; see $(l:basics/tutorial_1)the tutorial entries$(/l) for more in-depth knowledge on using this grid.",
"psi.book.page.spellProgrammer.1": "Hour Of Code",
"psi.book.entry.vectorPrimer": "A Primer On Vectors",
"psi.book.page.vectorPrimer.0": "$(thing)Psi$(0) uses the concept of a Vector extensively. Therefore, if you haven't the foggiest idea what a vector is, I strongly recommend you watch the video below.$(p)The explanation in the next few pages is $(l)simplified$() for beginners. Don't take it as definitive.",
"psi.book.page.vectorPrimer.1": "In the world of $(thing)Psi$(0) (and indeed in a $(thing)Minecraft$(0) world), all vectors are three-dimensional. In essence, they're just lists of three coordinates: $(o)x$(), $(o)y$(), $(o)z$().$(p)The $(o)x$()-coordinate represents east when positive and west when negative, the $(o)y$()-direction up and down, and the $(o)z$()-direction south and north.$(p)If this doesn't make sense yet, open the debug screen (F3) and run around, paying attention to the row labeled "XYZ:".$(br)You'll understand.",
"psi.book.page.vectorPrimer.2": "That list of three numbers on the debug screen is, in fact, the first type of vector you'll meet: a $(l)position vector$().$(p)A position vector simply represents the location of a block, or an entity, or perhaps some empty space in the world. A single fixed location, represented by a list [$(o)x$(), $(o)y$(), $(o)z$()].$(p)However, not all vectors represent positions-- and it's important to note that $(l)any three numbers in a list constitute a vector$().",
"psi.book.page.vectorPrimer.3": "An interesting fact about vectors is that they're extremely easy to add.$(p)For example, say we have a grass block at some location, which we choose to represent as [$(o)x$(), $(o)y$(), $(o)z$()].$(p)If we wish to add another vector (e.g. [0, 1, 0]) to this one, all we would have to do is add corresponding numbers:$(br)our vector sum would be [$(o)x$()+0, $(o)y$()+1, $(o)z$()+0], or just [$(o)x$(), $(o)y$()+1, $(o)z$()].",
"psi.book.page.vectorPrimer.4": "Since the $(o)y$()-component of our new vector has increased by one, and positive-$(o)y$() means up, this new vector simply represents the block above our grass block.$(p)The vector [0, 1, 0] represents the $(o)difference$() in position between our original and new vector, and it's our second type of vector: an $(l)offset vector$().",
"psi.book.page.vectorPrimer.5": "Offset vectors are what most spellslingers spend the majority of their time manipulating, so a mastery over them is key.$(p)Usually, a mage starts with a single position vector, then adds, subtracts, or otherwise combines offset vectors with this position vector in order to target their desired point in the world.",
"psi.book.page.vectorPrimer.6": "It's important to note that the idea "offset" and "position" vectors is conceptual; the terms are unique to the terminology of this tablet.$(p)Again: all $(thing)Psi$(0) vectors are just lists of three numbers, and there's nothing stopping you from pretending the distinction doesn't exist.$(p)Indeed, in some contexts outside the scope of this book, the distinction doesn't even make $(o)sense$().",
"psi.book.page.vectorPrimer.7": "However, $(o)within$() the context of $(thing)Psi$(0), putting offset and position vectors where they don't belong can lead to unpredictable results indeed.$(p)Two rules of thumb:$(p)$(li)Most $(thing)Operators$(0) that accept vectors should take no more than one position vector;$(p)$(li)Most $(thing)Tricks$(0) that affect blocks should take $(o)only$() a position vector.$(p)These are general rules, though; some $(thing)Spell Pieces$(0) do act differently.",
"psi.book.page.vectorPrimer.8": "Offset vectors have $(l)magnitudes$().$(p)You can think of an offset vector's magnitude as its "length," or the distance between a position in the world, and that same position when the offset vector is added to it.$(p)For example, our earlier offset vector [0, 1, 0] simply moved the position one block-length up, so it had a length, and therefore a magnitude, of 1.",
"psi.book.page.vectorPrimer.9": "Since a distance is always positive, so are vectors' magnitudes.$(p)Consider the vector [0, -3, 0] as an example: it represents down, three blocks-- yet the total distance moved is three blocks, and the "down" bit doesn't matter.$(p)Therefore, the magnitude of this vector is $(l)positive$() 3.",
"psi.book.page.vectorPrimer.10": "Magnitudes are a bit harder to calculate for vectors that $(o)aren't$() mostly zeroes.$(p)However, since the $(o)x$(), $(o)y$(), and $(o)z$() directions are all at right angles, we can use the well-known Pythagorean Theorem to calculate any vector's magnitude.$(p)In particular, the magnitude for a vector [$(o)p$(), $(o)q$(), $(o)r$()] is the number \u221a($(o)p$()\u00b2+$(o)q$()\u00b2+$(o)r$()\u00b2).",
"psi.book.page.vectorPrimer.11": "For example, the magnitude of the vector [3, -4, 0] is \u221a(3\u00b2+(-4)\u00b2+0\u00b2), which comes out to exactly 5.$(p)(Most of the time, a vector magnitude doesn't come out to a whole number, though.)$(p)Note that, while you $(o)can$() find the magnitude of a position vector, the number you get is largely meaningless-- who $(o)cares$() about your distance from [0, 0, 0] (which is some arbitrary point near bedrock and world spawn)?",
"psi.book.page.vectorPrimer.12": "Almost all vectors also have $(l)directions$().$(p)An offset vector's direction is, well, the direction something would move if it followed the vector in a straight line.$(p)For example, the direction of [0, 1, 0] is simply straight up.$(p)The vector [1, 0, -1], on the other hand, represents one block east and one block north, so its direction is just straight ahead, due northeast.",
"psi.book.page.vectorPrimer.13": "(Most directions aren't so nice, usually looking like "36.86 degrees north of west, 22.62 degrees below the horizon.")$(p)Note that the only vector without a direction is [0, 0, 0] (the $(l)zero vector$()), since you have to be going somewhere $(o)else$() to have a direction.$(p)Note that the direction of a position vector is almost as meaningless as its magnitude-- most $(thing)Spells$(0) don't need to know "where should I go to get away from bedrock at world spawn."",
"psi.book.page.vectorPrimer.14": "As a matter of fact, you can reconstruct any vector, given only its magnitude and direction, into a list of three numbers (which are known as the $(l)components$() of the vector).$(p)For example, the direction "up" and the magnitude 1 correspond to the vector [0, 1, 0].$(p)This isn't as surprising as it may seem: after all, if someone tells you which direction to go, and how far, you should know they want you to be.",
"psi.book.page.vectorPrimer.15": "There are several simple ways to manipulate position and offset vectors.$(p)First, we can add a position and an offset vector to get another position vector, as we did earlier with the grass block example.$(p)On the other hand, we can of course $(o)subtract$() two position vectors to get the offset vector representing the offset from one to the other:$(br)[$(o)x$(), $(o)y$()+1, $(o)z$()] \u2212 [$(o)x$(), $(o)y$(), $(o)z$()] = [0, 1, 0].",
"psi.book.page.vectorPrimer.16": "Perhaps more interestingly, we can add two offset vectors, to get a single offset representing their combination.$(p)Adding this offset to a position vector would be equivalent to first adding one of its components to that position vector, then adding the other.",
"psi.book.page.vectorPrimer.17": "And last, but most certainly not least, of the simple operations: we can $(l)scale$() a vector, by multiplying it by a number.$(p)Note that we're multiplying it by a number, and $(o)not$() another vector.$(p)If we wish to scale an vector [$(o)p$(), $(o)q$(), $(o)r$()] by a factor $(o)n$(), we simply multiply each of the vector's components by $(o)n$():$(br)$(o)n$()\u00b7[$(o)p$(), $(o)q$(), $(o)r$()] = [$(o)n$()\u00b7$(o)p$(), $(o)n$()\u00b7$(o)q$(), $(o)n$()\u00b7$(o)r$()].",
"psi.book.page.vectorPrimer.18": "This final operation relates nicely indeed to the concepts of magnitude and direction.$(p)When you scale a vector by a number $(o)n$(), you:$(p)$(li)multiply its magnitude by the absolute value of $(o)n$(), and$(p)$(li)don't change its direction if $(o)n$() is positive, but reverse its direction if $(o)n$() is negative.$(p)If $(o)n$()=0, then of course the resulting vector is the zero vector.",
"psi.book.page.vectorPrimer.19": "If, on the other hand, we set $(o)n$()=-1, then we get a vector with the same magnitude (since the absolute value of -1 is 1), but that points in the opposite direction (since -1 is negative).$(p)This vector is known as the $(l)negative$() of the original, and when the two are added we get the zero vector.$(p)This makes sense, since if we go in a direction, then go in the opposite direction for the same distance, our net movement is zero.",
"psi.book.page.vectorPrimer.20": "If, instead of multiplying, we $(o)divide$() a (nonzero) vector by its magnitude, we get a vector with magnitude 1 (since anything divided by itself is 1), but the same direction (since magnitudes are always positive).$(p)This is an important and well-known operation, known as $(l)normalizing$() a vector; the vector that results (and, in fact, any vector with magnitude 1) is called a $(l)unit vector$().",
"psi.book.page.vectorPrimer.21": "Unit vectors have a fixed magnitude, so they only represent direction.$(p)Many $(thing)Spell Pieces$(0) related to direction return unit vectors, like $(piece)Operator: Vector Axis Raycast$(0) and $(piece)Operator: Entity Look$(0).$(p)Indeed, there are $(thing)Operators$(0) to do $(o)most$() of the vector operations laid out in this article, usually with self-explanatory names.",
"psi.book.page.vectorPrimer.22": "The operations and their corresponding $(thing)Operators$(0) are as follows:$(p)$(li)Negating is $(piece)Operator: Vector Negate$(0);$(p)$(li)Normalizing is $(piece)Operator: Vector Normalize$(0);$(p)$(li)Scaling is $(piece)Operator: Vector Multiply$(0) and $(piece)Operator: Vector Divide$(0);$(p)$(li)Taking the magnitude is $(piece)Operator: Vector Magnitude$(0);$(p)$(li)Adding is $(piece)Operator: Vector Sum$(0);$(p)$(li)Subtracting is $(piece)Operator: Vector Subtract$(0).",
"psi.book.page.vectorPrimer.23": "Finally: vectors are still lists of three numbers. Don't lose sight of that.$(p)In a $(l:basics/spell_programmer)$(item)Spell Programmer$(0)$(/l), they can be constructed from up to three numbers with $(piece)Operator: Vector Construct$(0).$(p)Conversely, a vector can also be broken back down into numbers with $(piece)Operator: Extract X$(0), $(piece)Operator: Extract Y$(0), and $(piece)Operator: Extract Z$(0).",
"psi.book.page.vectorPrimer.24": "Congratulations on making it through this tutorial!$(p)Again, this is just an introduction to vectors-- I've not said anything about dot or cross products, or vector projections, for example.$(p)But this should be more than enough to put together some quite interesting $(thing)Spells$(0) already.$(p)That's all-- now go forth and spellsling!",
"psi.book.entry.tutorial1": "Tutorial (1): Writing A Spell",
"psi.book.page.tutorial1.0": "Congratulations on getting acquainted with your brand-new $(thing)CAD$(0)!$(p)This tablet will serve as a reference manual for this mod, but certain entries (like this one) are tutorials, introducing you to the concepts and terms of a proper spellslinger.$(p)Don't worry, this is the longest tutorial, as it covers all the basics.",
"psi.book.page.tutorial1.1": "$(o)Note that many keywords in $(item)colored$(0) $(piece)text$(0) are links, and can be clicked on to learn more about their respective items or concepts.$()$(p)To get started with $(thing)Spell$(0) programming, you'll need (duh) a $(l:basics/spell_programmer)$(item)Spell Programmer$(0)$(/l).$(p)Additionally, to actually execute your $(thing)Spells$(0), you'll need a better $(thing)CAD$(0) than ** you have right now-- you can construct one in your $(l:basics/cad_assembler)$(item)CAD Assembler$(0)$(/l).",
"psi.book.page.tutorial1.2": "To that end, you probably want to make a $(l:components/core#basic)$(item)Basic CAD Core$(0)$(/l) and $(l:components/socket#basic)$(item)Basic CAD Socket$(0)$(/l).$(p)You don't have to make another $(l:components/assembly)$(thing)Assembly$(0)$(/l); you can put your current $(thing)CAD$(0) in a crafting grid to revert it back to one (since it's pretty much just an $(l:components/assembly)$(thing)Assembly$(0)$(/l) anyway).$(p)Additionally, $(thing)Spells$(0) can't be cast directly out of a $(thing)CAD$(0); instead they're stored in $(l:items/spell_bullet)$(thing)Spell Bullets$(0)$(/l), so to get rolling you'll need a small handful of those as well.",
"psi.book.page.tutorial1.3": "Once all your materials are gathered, the standard workflow for $(thing)Spell$(0) creation goes as follows:$(p)$(li)Construct a $(thing)Spell$(0) in the $(l:basics/spell_programmer)$(item)Programmer$(0)$(/l);$(br)$(li)Copy the $(thing)Spell$(0) into a $(l:items/spell_bullet)$(thing)Spell Bullet$(0)$(/l);$(br)$(li)Load the $(l:items/spell_bullet)$(thing)Spell Bullet$(0)$(/l) into your $(thing)CAD$(0) using the $(l:basics/cad_assembler)$(item)CAD Assembler$(0)$(/l);$(br)$(li)Hold your $(thing)CAD$(0), point, and cast.$(p)In this tutorial and the next, we'll walk you through this process.",
"psi.book.page.tutorial1.4": "When you open up your $(l:basics/spell_programmer)$(item)Spell Programmer$(0)$(/l), you'll see a large grid-- this is where $(thing)Spells$(0) are made, and where the magic happens.$(p)$(thing)Psi$(0)'s programming system isn't $(o)exactly$() a traditional, complex one; instead, $(thing)Spells$(0) are composed of simple actions, called $(thing)Tricks$(0), executed in order.$(p)The whole mod centers around simply getting $(thing)Tricks$(0) to do what you want them to.",
"psi.book.page.tutorial1.5": "$(thing)Psi$(0)'s $(thing)Spells$(0) are all created on the $(l:basics/spell_programmer)$(item)Programmer$(0)$(/l)'s grid from $(thing)Spell Pieces$(0); you can add as many pieces of as many types to a grid as you want, though not all arrangements of $(thing)Spell Pieces$(0) will produce valid $(thing)Spells$(0).$(p)To add a piece to the grid, right-click where you want the piece to go, and select from the menu of pieces that pops up.",
"psi.book.page.tutorial1.6": "When selecting from the menu of $(thing)Spell Pieces$(0), you can hover over one to see its name, and click on it to place it in the grid.$(p)Don't worry about the myriad of pieces that appear for you; you can simply type to search for specific pieces, and press Enter to place the first search result.$(p)You can hold Shift and hover over the "?" button on the bottom-right to see the full list of shortcuts.",
"psi.book.page.tutorial1.7": "Start by placing the piece called $(piece)Trick: Debug$(0) anywhere on the grid.$(p)As mentioned before, $(thing)Tricks$(0) like this one are the $(thing)Spell Pieces$(0) responsible for interacting with the world.$(p)This is the simplest $(thing)Trick$(0); all it does is say something in your chat. Yet $(thing)Tricks$(0) can use your $(thing)Psi energy$(0) to do a huge variety of things.",
"psi.book.page.tutorial1.8": "Select a grid piece $(l)adjacent$() to your $(piece)Trick: Debug$(0), and place the piece called $(piece)Selector: Caster$(0) there.$(p)$(thing)Selectors$(0) are the $(thing)Spell Pieces$(0) that provide information about the surrounding world to $(thing)Spells$(0).$(p)This particular piece represents you, the eventual caster of this $(thing)Spell$(0). You'll probably use this one rather often, as it's a natural starting-point for your $(thing)Spells$(0).",
"psi.book.page.tutorial1.9": "Nearly all $(thing)Spell Pieces$(0) need $(l)parameters$(), which tell the pieces what to perform their actions on.$(p)For example, we know that $(piece)Trick: Debug$(0) sends something to chat; its first parameter tells it $(o)what$() to say.$(p)$(o)Parameters also have $(l)data types$()$(o), or $(l)types$()$(o) for short, but we'll worry about those in a later tutorial.$()",
"psi.book.page.tutorial1.10": "Left-click your $(piece)Trick: Debug$(0) piece; you should see a panel appear on the left-hand side with two rows. Each row should have a label and several small arrows.$(p)These two rows represent the two parameters that $(piece)Trick: Debug$(0) takes.$(p)Ignore the row labeled "Number" for now; just know that the dot in the center means it's optional. For a $(thing)Spell$(0) to function, all $(o)non$()-optional parameters must be filled.",
"psi.book.page.tutorial1.11": "Look at the arrows labeled "Target," and select ** corresponding to where you placed $(piece)Selector: Caster$(0) (for example, if you placed it to the right of $(piece)Trick: Debug$(0), select the rightmost arrow that points left), so it appears that the $(thing)Selector$(0) piece is pointing towards the $(thing)Trick$(0) piece.",
"psi.book.page.tutorial1.12": "This will make the $(thing)Trick$(0) use the $(thing)Selector$(0) as its "Target" parameter.$(p)We say that $(piece)Trick: Debug$(0) $(l)accepts$() or $(l)takes$() $(piece)Selector: Caster$(0) as its "Target" parameter.$(p)Parameters are also known as $(l)arguments$(), or simply $(l)inputs$().$(p)$(o)Technical note: In programming-vocabulary there's a subtle difference in the terms, but it's beyond the scope of this tablet.$()",
"psi.book.page.tutorial1.13": "Your final $(thing)Spell$(0) should look something like this",
"psi.book.page.tutorial1.14": "At this point, the X in the upper-left hand corner of the $(l:basics/spell_programmer)$(item)Programmer$(0)$(/l) should have turned into a check-mark.$(p)A check-mark means that the $(thing)Spell$(0) $(l)compiled successfully$() (which is a compact way of saying "the $(l:basics/spell_programmer)$(item)Programmer$(0)$(/l) made sure that all the $(thing)Spell Pieces$(0) you've placed fit together correctly"). ",
"psi.book.page.tutorial1.15": "If at any time the X is present (which means that the compilation $(l)failed$() or $(l)errored$()), you can hover over it to see the problem with your $(thing)Spell$(0) and correct that problem.$(p)Once your $(thing)Spell$(0) compiles successfully, it can be copied into a $(l:items/spell_bullet)$(thing)Spell Bullet$(0)$(/l) and cast. And that's exactly what we'll do in $(l:basics/tutorial_2)the next tutorial$(/l)!",
"psi.book.entry.tutorial2": "Tutorial (2): Casting A Spell",
"psi.book.page.tutorial2.0": "So, you've written your first $(thing)Spell$(0)! Actually casting it, though, will take a few extra steps.$(p)First, close out your $(l:basics/spell_programmer)$(item)Spell Programmer$(0)$(/l), hold a $(l:items/spell_bullet)$(thing)Spell Bullet$(0)$(/l) (which you should have prepared in the last tutorial), and use ($(k:use)) the bullet on the Programmer. You should hear a chime, and the bullet should rename itself to "Debug."",
"psi.book.page.tutorial2.1": "The bullet now contains a copy of the $(thing)Spell$(0) you've written, and is ready to be loaded into your $(thing)CAD$(0).$(p)To load a $(l:items/spell_bullet)$(thing)Spell Bullet$(0)$(/l) into your $(thing)CAD$(0), open your $(l:basics/cad_assembler)$(item)CAD Assembler$(0)$(/l) and insert your $(thing)CAD$(0) into the leftmost slot. Some of the slots below it should open; place the bullet with the $(thing)Spell$(0) you've written in one of these slots. Take your $(thing)CAD$(0) back out.",
"psi.book.page.tutorial2.2": "$(thing)CADs$(0) can hold multiple $(l:items/spell_bullet)$(thing)Spell Bullets$(0)$(/l), and therefore multiple $(thing)Spells$(0); the active $(thing)Spell$(0) to be cast can be switched on-the-fly.$(p)To select a $(thing)Spell$(0) to cast, hold your $(thing)CAD$(0) in either hand and hold down the $(thing)Psi master keybind$(0) ($(k:psimisc.keybind)).$(p)A HUD should appear; hover over the $(thing)Spell$(0) labeled "Debug" (** you just wrote) and release the key to select it.",
"psi.book.page.tutorial2.3": "When you cast the $(thing)Spell$(0) ($(k:use)), you should see displayed in chat a long block of text that includes your username and coordinates. If so: congratulations! You've managed to write and cast your first $(thing)Spell$(0)!$(p)If you need to craft more $(l:components/psidust)$(item)Psidust$(0)$(/l), re-open the HUD and select a slot without a $(thing)Spell$(0) stored, then cast at $(item)Redstone Dust$(0) as you normally would.",
"psi.book.page.tutorial2.4": "$(l)A sidenote: you should carry only one $(thing)CAD$(0) at a time.$()$(p)If more than one is carried, their channeled $(thing)Psi$(0) energies interfere, shorting out any $(thing)Spells$(0) cast. This phenomenon, known as "cast jamming," is best avoided by simply keeping to one-$(thing)CAD$(0)-per-mage.$(p)Once you've successfully cast your Debug $(thing)Spell$(0), you can move on to $(l:basics/tutorial_3)the next tutorial$(/l).",
"psi.book.entry.tutorial3": "Tutorial (3): Types & Numbers",
"psi.book.page.tutorial3.0": "Open up your $(l:basics/spell_programmer)$(item)Spell Programmer$(0)$(/l) and take a look at your "Debug" $(thing)Spell$(0) again.$(p)Remember the "Number" parameter on $(piece)Trick: Debug$(0) that we saw in $(l:basics/tutorial_1)the first tutorial$(/l)? We mentioned previously that that parameter has an extra dot in the center, meaning it can be disabled. But this time, we $(o)won't$() disable it.",
"psi.book.page.tutorial3.1": "The "Number" parameter of $(piece)Trick: Debug$(0), when used, is printed as a label of sorts, so that multiple copies of $(piece)Trick: Debug$(0) in a complex $(thing)Spell$(0) can be differentiated.$(p)The $(l)type$() of this parameter is "Number," which means that the parameter will only accept arguments that output (or $(l)return$()) Numbers.$(p)The first parameter, "Target," accepts the special type "Any," which means it can accept anything.",
"psi.book.page.tutorial3.2": "If you hold Shift and hover over a Spell Piece, it'll tell you the types of all its parameters, as well as its output's type. For example, we can see that the $(piece)Selector: Caster$(0) piece returns an Entity, which isn't a Number. So we'll need some other piece to represent one.",
"psi.book.page.tutorial3.3": "Tooltip for $(piece)Selector: Caster$(0); it returns an Entity",
"psi.book.page.tutorial3.4": "Choose an empty grid piece adjacent to $(piece)Trick: Debug$(0), and place the piece called $(piece)Constant: Number$(0).$(p)If you Shift-hover over this piece, you'll see that it $(o)does$() return a Number (actually, it returns a Number Constant, which is a Number but more specific).$(p)Therefore, if you left-click your $(piece)Trick: Debug$(0) again and point its Number parameter at the $(piece)Constant: Number$(0), your $(thing)Spell$(0) should compile.",
"psi.book.page.tutorial3.5": "To run your new-and-improved Debug $(thing)Spell$(0), you might believe that you need to unload the bullet, re-copy the $(thing)Spell$(0), reload the bullet, and re-select the $(thing)Spell$(0).$(p)Luckily, your $(thing)CAD$(0) comes with a shortcut: simply select your Debug $(thing)Spell$(0) on your $(thing)CAD$(0) and swipe ($(k:use)) your $(thing)CAD$(0) over your $(l:basics/spell_programmer)$(item)Programmer$(0)$(/l), and the $(thing)Spell$(0) stored in the corresponding bullet will update itself to the $(l:basics/spell_programmer)$(item)Programmer$(0)$(/l)'s version.",
"psi.book.page.tutorial3.6": "If you cast your Debug $(thing)Spell$(0) now, you'll notice that you get the same long block of text as before, but with a bracketed zero in front: in fact, the same zero that was displayed in the $(piece)Constant: Number$(0) piece when you placed it.$(p)So the logical next question is: How do we display a number $(o)other$() than zero?",
"psi.book.page.tutorial3.7": "Well, the $(piece)Constant: Number$(0) piece is special: to set its stored constant, all you have to do is select the piece and simply type a new number.$(p)All other $(thing)Spell Pieces$(0) are configured only from the left-hand parameter panel.$(p)$(o)Technical wayside: all Number Constants count as Numbers, but plain Numbers don't count as Number Constants. Only $(thing)Constant$(0) $(thing)Spell Pieces$(0) return Number Constants.$()",
"psi.book.page.tutorial3.8": "Try editing the number stored in the $(piece)Constant: Number$(0), updating the $(thing)Spell$(0) stored in your $(thing)CAD$(0), and re-casting. You should see that the prefixed number has, in fact, changed! Neat!",
"psi.book.page.tutorial3.9": "Now, here's the thing: we've hooked $(piece)Trick: Debug$(0) up to two different inputs at once.$(p)Truth be told, $(o)most$() $(thing)Spell Pieces$(0) take two (or even three) inputs. And when it comes right down to it, your $(thing)Spell$(0)'s inputs might end up adjacent to one another.$(p)That's where $(piece)Connectors$(0) come in.",
"psi.book.page.tutorial3.10": "Connectors are simple pieces, yet powerful: They take one input, of any type, and return that same input. Thus, if a certain $(thing)Spell Piece$(0) requires as input another piece that's two grid-spaces away, you can connect them with a $(piece)Connector$(0).",
"psi.book.page.tutorial3.11": "Bridge to Terabithia",
"psi.book.page.tutorial3.12": "Of course, the true power of a $(piece)Connector$(0) is that they can connect to each $(o)other$(): so you can of course daisy-chain them together to connect $(thing)Spell Pieces$(0) from as far-away as you please.$(p)Play around with some $(piece)Connectors$(0), and as soon as you feel comfortable with them you can move on to $(l:basics/tutorial_5)the next tutorial$(/l)!",
"psi.book.page.tutorial3.13": "The long way around",
"psi.book.entry.tutorial4": "Tutorial (4): Move It",
"psi.book.page.tutorial4.0": "Okay, okay. I know what you're thinking: "This is boring. When do we start doing cool stuff?" Well... now!$(p)Let's introduce a $(thing)Trick$(0) that actually interacts with the world-- introducing: $(piece)Trick: Add Motion$(0).$(p)This $(thing)Trick$(0) takes an entity, and adds motion to it (i.e. gives it a push) in a certain direction.",
"psi.book.page.tutorial4.1": "Examples of entities include: you, the caster; a chicken; a zombie; a minecart; a falling sand block; an arrow; the Wither.$(p)This $(thing)Trick$(0) takes as parameters an Entity (which represents the entity to move), a Vector (the direction to push it in), and a Number Constant (how hard the $(thing)Trick$(0) should push the entity).$(p)$(o)Note: If you don't understand what the word "vector" means, $(l:basics/vector_primer)this entry$(/l) should serve as a good introduction.$()",
"psi.book.page.tutorial4.2": "Let's write a $(thing)Spell$(0) that, when cast, simply boosts its caster forwards, using $(piece)Trick: Add Motion$(0).$(p)As mentioned before, $(piece)Selector: Caster$(0) returns an Entity (namely: you, the caster), so we can use that as the first parameter to $(piece)Trick: Add Motion$(0).$(p)We'd like the $(thing)Trick$(0) to boost you $(o)forward$()-- that is, $(o)in the direction you're looking$(). To do that, let's introduce our next piece: $(piece)Operator: Entity Look$(0).",
"psi.book.page.tutorial4.3": "No $(thing)Operator$(0) pieces change the world around them in any way, nor do they pull information from it (with a few exceptions). Instead, they merely $(o)transform$() information into more useful forms.$(p)In particular, $(piece)Operator: Entity Look$(0) accepts an Entity, and returns a unit Vector: the direction the Entity is looking.$(p)Thus, one of these, hooked up to a $(piece)Selector: Caster$(0), will return a Vector that points wherever you're looking at.",
"psi.book.page.tutorial4.4": "Finally, for the last parameter of $(piece)Trick: Add Motion$(0), a simple $(piece)Constant: Number$(0) will do.$(p)Let's put this $(thing)Spell$(0) all together: first, open up your $(l:basics/spell_programmer)$(item)Spell Programmer$(0)$(/l) and clear any $(thing)Spell$(0) currently on it. Then, place a $(piece)Trick: Add Motion$(0) near the middle of the grid.",
"psi.book.page.tutorial4.5": "Place a $(piece)Selector: Caster$(0) directly above the $(thing)Trick$(0), an $(piece)Operator: Entity Look$(0) to its right, and a $(piece)Constant: Number$(0) to its left.$(p)Fill in a value for the $(thing)Constant$(0) (I recommend the number 3).$(p)Place a $(piece)Connector$(0) between the $(thing)Operator$(0) and the $(thing)Selector$(0), and then set up all the parameters for the $(thing)Operator$(0) and $(thing)Trick$(0) so the $(thing)Spell$(0) compiles-- it should look something like the image on the next page.",
"psi.book.page.tutorial4.6": "When push comes to shove",
"psi.book.page.tutorial4.7": "Copy the $(thing)Spell$(0) into your $(thing)CAD$(0), look straight ahead, and cast. If you get thrown forward, then congratulations! You've just finished writing your first real $(thing)Spell$(0)!$(p)$(o)Note: Casting your new $(thing)Spell$(0) too many times in a row might be bad for your health. More on this in $(l:basics/tutorial_5)the next tutorial$(/l).$()",
"psi.book.entry.tutorial5": "Tutorial (5): Limits",
"psi.book.page.tutorial5.0": "Open your $(l:basics/spell_programmer)$(item)Spell Programmer$(0)$(/l) again, and review the $(thing)Spell$(0) you wrote in $(l:basics/tutorial_4)the last tutorial$(/l).$(p)When it compiled correctly, you should have seen five icons appear to the right of the grid, each with two numbers. These numerical stats define the practical limits on exactly what $(thing)Spells$(0) you're able to cast.",
"psi.book.page.tutorial5.1": "The stats for your Add Motion $(thing)Spell$(0) (assuming your constant was 3)",
"psi.book.subsec.tutorial5.2": "Complexity",
"psi.book.page.tutorial5.2": "The first stat is $(thing)Complexity$(0), the total number of $(thing)Operators$(0), $(thing)Selectors$(0), and non-debug $(thing)Tricks$(0) in the $(thing)Spell$(0).$(p)Its maximum value is determined by the $(l:components/core)$(thing)CAD Core$(0)$(/l) you have installed; if a $(thing)Spell$(0)'s $(thing)Complexity$(0) exceeds your $(thing)CAD$(0)'s capacity, it won't be castable.",
"psi.book.subsec.tutorial5.3": "Potency",
"psi.book.page.tutorial5.3": "The second is $(thing)Potency$(0), capped by your $(l:components/assembly)$(thing)Assembly$(0)$(/l) component; the approximate total power draw of all $(thing)Tricks$(0) used in the $(thing)Spell$(0).$(p)Some $(thing)Tricks$(0) have a fixed $(thing)Potency$(0) cost per-use. However, most $(thing)Tricks$(0) that have a Number Constant-type parameter use it to determine their $(thing)Potency$(0); the higher the constant, the greater the $(thing)Potency$(0).",
"psi.book.subsec.tutorial5.4": "Cost",
"psi.book.page.tutorial5.4": "The third stat, $(thing)Cost$(0), is unique in that your $(thing)CAD$(0) sets no limits on it. Instead, each time a $(thing)Spell$(0) is cast, it consumes its $(thing)Cost$(0) from your own body's $(thing)Psi energy$(0).$(p)The first number shown is the $(o)ideal$() $(thing)Cost$(0) of the $(thing)Spell$(0)-- all $(l:components/assembly)$(thing)CAD Assemblies$(0)$(/l) have flaws that increase it.",
"psi.book.page.tutorial5.5": "The true $(thing)Cost$(0) of casting with your $(thing)CAD$(0) is the parenthesized number on the $(l:basics/spell_programmer)$(item)Programmer$(0)$(/l) display, and the higher an $(l:components/assembly)$(thing)Assembly$(0)$(/l)'s $(thing)Efficiency$(0), the closer to ideal the actual $(thing)Cost$(0) of casting from your $(thing)CAD$(0) becomes.",
"psi.book.page.tutorial5.6": "Your $(thing)Psi energy$(0) regenerates at around 500 units per second, limiting the speed at which you can cast $(thing)Spells$(0).$(p)Your current level of $(thing)Psi energy$(0) can be accessed from within a $(thing)Spell$(0) with $(piece)Selector: Caster Energy$(0).",
"psi.book.page.tutorial5.7": "Note that if you cast a $(thing)Spell$(0) without enough $(thing)Psi energy$(0) available (known as $(l)overdrawing$()), your $(thing)CAD$(0) will draw the excess cost from your own health, and promptly disable itself until your $(thing)Psi energy$(0) fully regenerates, for your own protection.$(p)A $(l:components/battery)$(thing)Battery$(0)$(/l) added to a $(thing)CAD$(0) can guard against this.$(p)Be careful-- overdrawing has consequences that are painful, and maybe even lethal!",
"psi.book.subsec.tutorial5.8": "Projection",
"psi.book.page.tutorial5.8": "The fourth stat displayed on the $(l:basics/spell_programmer)$(item)Programmer$(0)$(/l) is $(thing)Projection$(0): the total number of non-debug $(thing)Tricks$(0) in the $(thing)Spell$(0).$(p)Your $(thing)CAD$(0)'s $(l:components/core)$(thing)Core$(0)$(/l) determines your maximum $(thing)Projection$(0) per-$(thing)Spell$(0); too many $(thing)Tricks$(0) and the $(thing)Spell$(0) is uncastable.",
"psi.book.subsec.tutorial5.9": "Bandwidth",
"psi.book.page.tutorial5.9": "And the fifth and final stat is $(thing)Bandwidth$(0), capped by your $(l:components/socket)$(thing)CAD Socket$(0)$(/l): the width or height of the $(thing)Spell$(0), measured in grid spaces-- whichever is larger.$(p)This is, with a bit of ingenuity, one of the more interesting stats to work with; if your $(thing)Spell$(0) is too big, the technique of moving some pieces around and eliminating others to pack it into a smaller space is known as $(l)compression$().",
"psi.book.page.tutorial5.10": "There's one final limitation on $(thing)Spells$(0): no $(thing)Trick$(0) can affect anything more than 32 blocks away from its $(l:items/spell_bullet#focal_point)$(thing)Focal Point$(0)$(/l) (for a plain $(l:items/basic_bullet)$(item)Spell Bullet$(0)$(/l), that's just you, the caster), excepting the caster of the $(thing)Spell$(0) themself.$(p)A $(thing)Spell$(0) that attempts to do so will display an error in chat, then $(l)fizzle$().$(p)When a $(thing)Spell$(0) fizzles, it harmlessly disperses its stored $(thing)Psi energy$(0), and any remaining $(thing)Tricks$(0) it would otherwise execute don't happen.",
"psi.book.page.tutorial5.11": "To clarify the earlier exception mentioned:$(br)Certain types of $(l:items/spell_bullet)$(thing)Spell Bullets$(0)$(/l) have $(l:items/spell_bullet#focal_point)$(thing)Focal Points$(0)$(/l) that $(o)aren't$() their casters-- yet in these cases, their stored $(thing)Spells$(0) can still affect their casters through $(piece)Selector: Caster$(0), no matter how far away their $(l:items/spell_bullet#focal_point)$(thing)Focal Points$(0)$(/l) are.$(p)There's $(l:basics/tutorial_6)one final tutorial$(/l) lined up, putting most of what we've learned together, and then we'll cut you loose into the wider world of $(thing)Psi$(0). Good luck!",
"psi.book.entry.tutorial6": "Tutorial (6): EXPLOSION",
"psi.book.page.tutorial6.0": "Do you like explosions?$(p)Of course you do. Everyone loves explosions!$(p)So let's make a $(thing)Spell$(0) that blows up whatever you're looking at when you cast it.$(p)What could possibly go wrong?",
"psi.book.page.tutorial6.1": "To write this $(thing)Spell$(0), let's start with the $(thing)Trick$(0) we'll use to cause an explosion, and work backwards.$(p)Conveniently, it's named $(piece)Trick: Explode$(0)-- so open up your $(l:basics/spell_programmer)$(item)Spell Programmer$(0)$(/l), clear out the grid, and place a $(piece)Trick: Explode$(0) near the middle.$(p)Shift-hovering over it reveals that it accepts a Vector and a Number Constant as parameters.",
"psi.book.page.tutorial6.2": "The Number Constant parameter represents the explosion's power-- easy enough to fill with a $(piece)Constant: Number$(0) piece.$(p)The Vector, on the other hand, accepts the position vector of the location you want the explosion to go off at. This is what'll take a bit more effort to calculate.",
"psi.book.page.tutorial6.3": "$(l:basics/tutorial_5)Last tutorial$(/l), we used $(piece)Operator: Entity Look$(0).$(p)However, that $(thing)Operator$(0) returns a unit vector, and $(piece)Trick: Explode$(0) needs a position, so feeding that piece directly into the $(thing)Trick$(0) would probably not produce the results we want.$(p)So let's introduce another $(thing)Operator$(0): namely, $(piece)Operator: Entity Position$(0).",
"psi.book.page.tutorial6.4": "$(piece)Operator: Entity Position$(0) accepts an Entity (like the caster of the $(thing)Spell$(0)), and returns that entity's position (to be more precise: for a player like you, it returns your position at eye-level).$(p)However, we don't want to pass this directly into $(piece)Trick: Explode$(0), either-- because it would literally explode in your face when cast.",
"psi.book.page.tutorial6.5": "What we $(o)could$() do here is simply scale up the vector we got from $(piece)Operator: Entity Look$(0) by a factor of, say, 10, and then add this to $(piece)Operator: Entity Position$(0)'s output.$(p)When fed into $(piece)Trick: Explode$(0), this would create a $(thing)Spell$(0) that, when cast, would create an explosion $(o)exactly ten blocks away from you, in the direction you're looking$().",
"psi.book.page.tutorial6.6": "But the limitations of this $(thing)Spell$(0) seem obvious: if you want to blow something up that's closer or further than ten blocks away, you'll have to do some awkward moving-around and guesstimating of distances.$(p)Not very practical, all things considered.$(p)Instead, let's use a smarter operator: $(piece)Operator: Vector Raycast$(0).",
"psi.book.page.tutorial6.7": "This $(thing)Operator$(0)'s function is intuitively simple; it accepts a position vector and a "ray" vector (which is just a vector to represent direction).$(p)Its return value pretty much represents "if I stood there and looked in that direction, what position would I be looking at?", which makes it perfect for our purposes.$(p)For more details, including what the "Max" argument does, read the page about $(piece)Operator: Vector Raycast$(0).",
"psi.book.page.tutorial6.8": "So! To build this $(thing)Spell$(0), let's work backwards.$(p)If you haven't done so already, place a $(piece)Constant: Number$(0) near the $(piece)Trick: Explode$(0) (if you're still using the $(thing)CAD$(0) you built in $(l:basics/tutorial_1)the first tutorial$(/l), 1.4 would be a good number to set it to).$(p)Then, place a $(piece)Operator: Vector Raycast$(0) next to the $(thing)Trick$(0) as well, and hook the $(thing)Trick$(0) up to the other two $(thing)Spell Pieces$(0).",
"psi.book.page.tutorial6.9": "Next, place an $(piece)Operator: Entity Position$(0) and an $(piece)Operator: Entity Look$(0), then connect your $(piece)Operator: Vector Raycast$(0) to the two.$(p)Make sure to hook "Position" up to Entity Position and "Ray" up to Entity Look, and not the other way around, or else you'll get some odd results/errors when you cast the $(thing)Spell$(0).$(p)Finally, place a $(piece)Selector: Caster$(0), and hook this up to the two Entity $(thing)Operators$(0).",
"psi.book.page.tutorial6.10": "Something along these lines",
"psi.book.page.tutorial6.11": "Once your $(thing)Spell$(0) compiles successfully, load it into your $(thing)CAD$(0), take careful aim at something (preferably something you don't care much about), and cast.$(p)If that thing you're looking at explodes, take a moment to savor your newfound power.$(p)Just, er, try not to cast it at your own two feet.",
"psi.book.page.tutorial6.12": "One final note: Try casting your new "Explode" $(thing)Spell$(0) at something that's more than 32 blocks away (or at nothing, like the sky).$(p)You should see no explosion, and an error should pop up in chat, telling you "$(c)Spell Target is outside maximum 32 block radius.$(0)" (this limit was discussed last tutorial).$(p)These sorts of errors popping up in chat can get rather annoying.",
"psi.book.page.tutorial6.13": "To fix this, simply place an $(piece)Error Suppressor$(0) piece anywhere on the grid, and the resulting $(thing)Spell$(0) will instead fail silently, when cast.$(p)You might want to remove the piece when debugging, though. Errors $(o)can$() be useful sometimes.",
"psi.book.page.tutorial6.14": "This concludes this set of tutorials!$(p)Have a read through the rest of this book for an idea of exactly what you can do with this mod. Experienced mages can do terrifying things, after all.$(p)It's up to you to experiment with your $(thing)CAD$(0) and $(l:basics/spell_programmer)$(item)Spell Programmer$(0)$(/l), and to create your own unique $(thing)Spells$(0).$(p)Good luck, and welcome to the wide world of $(thing)Psi$(0)!",
"psi.book.entry.evalOrder": "Evaluation Order",
"psi.book.page.evalOrder.0": "Nearly all $(thing)Tricks$(0) execute simultaneously with the $(thing)Spell$(0) containing them. Nonetheless, to use $(piece)flow control tricks$(0), you'll need a basic knowledge of evaluation order; that is, the order that $(thing)Spell Pieces$(0) get evaluated in.",
"psi.book.page.evalOrder.1": "There are three basic rules to evaluation order; they're explained in more detail in the following pages, but a brief summary follows:$(p)$(li)When a $(thing)Spell$(0) is executed, its $(thing)Tricks$(0) are each evaluated (and then executed) left-to-right, then top-to-bottom;$(p)$(li)Any $(thing)Spell Piece$(0) being evaluated will evaluate all of its inputs first;$(p)$(li)A $(thing)Spell Piece$(0) is evaluated at most once per $(thing)Spell$(0) execution, when its value is first required.",
"psi.book.page.evalOrder.2": "The first rule should be rather self-explanatory: a $(thing)Trick$(0) placed higher on the grid is executed earlier than a $(thing)Trick$(0) placed lower, and when two or more $(thing)Tricks$(0) are in the same row, the leftmost one executes first.$(p)Thus, the $(thing)Spell$(0) shown on the next page should display "1.0", "2.0", "3.0", and "4.0" in chat, in that exact order.",
"psi.book.page.evalOrder.3": "Make it count",
"psi.book.page.evalOrder.4": "The second rule is just as simple; a $(thing)Spell Piece$(0) is only evaluated when its value is required.$(p)However, notably, the converse is $(o)also$() true-- namely: if a $(thing)Spell Piece$(0) $(o)isn't$() required for a $(thing)Trick$(0), directly or indirectly, it's never evaluated when the $(thing)Spell$(0) executes.$(p)Any $(thing)Spell Piece$(0) that isn't connected to a $(thing)Trick$(0) causes $(l)undefined behavior$()-- no guarantees on $(thing)Spell$(0) behavior exist in these cases.",
"psi.book.page.evalOrder.5": "Not suggested",
"psi.book.page.evalOrder.6": "The third and final rule is a bit more subtle, and is best illustrated in the $(thing)Spell$(0) on the next page:$(p)A $(thing)Spell Piece$(0) only evaluates once, and returns $(o)the exact same value$() for subsequent evaluations. Therefore, the four copies of $(piece)Trick: Debug$(0) displayed will all output the $(o)same$() number, since the $(piece)Operator: Random$(0) only gets evaluated once.$(p)$(piece)Trick: Evaluate$(0) can be used to evaluate a $(thing)Spell Piece$(0) "early."",
"psi.book.page.evalOrder.7": "First-come first-serve",
"psi.book.category.components": "Materials & Components",
"psi.book.category.components.desc": "This section of the book details all the new raw materials $(thing)Psi$(0) adds to the game, as well as all the components you need to construct a proper $(thing)CAD$(0).",
"psi.book.entry.psidust": "Psidust",
"psi.book.page.psidust.0": "$(item)Psidust$(0) is a material transmuted from $(item)Redstone Dust$(0) by an unfocused burst of $(thing)Psi energy$(0), and is, as such, a good conductor of said energies.$(p)Therefore, it's a critical component in low-tier $(thing)CADs$(0), since it's used in simple $(l:components/core#basic)$(thing)CAD Cores$(0)$(/l), $(l:components/socket#basic)$(thing)Sockets$(0)$(/l), and $(l:components/battery#basic)$(thing)Batteries$(0)$(/l), as well as all $(l:components/colorizer)$(thing)CAD Colorizers$(0)$(/l).$(p)It's also used in $(l:items/spell_bullet)$(thing)Spell Bullets$(0)$(/l).",
"psi.book.page.psidust.1": "To create $(item)Psidust$(0), first throw some $(item)Redstone Dust$(0) on the ground.$(p)Then, stand nearby and cast ($(k:use)) with a $(thing)CAD$(0) $(l)that has no $(thing)Spell$(0) selected$() to convert the redstone into $(item)Psidust$(0).$(p)$(item)Psidust$(0) can also be created with any of the $(piece)infusion tricks$(0).",
"psi.book.entry.psimetal": "Psimetal",
"psi.book.page.psimetal.0": "$(item)Psimetal$(0) is a material transmuted from $(item)Gold Ingots$(0) that conducts, stores, and transfers $(thing)Psi energy$(0) $(o)much$() better than $(l:components/psidust)$(item)Psidust$(0)$(/l) does.$(p)In addition to being a component in more powerful $(l:components/core)$(thing)CAD Cores$(0)$(/l), $(l:components/socket)$(thing)Sockets$(0)$(/l), and $(l:components/battery#extended)$(thing)Batteries$(0)$(/l), it can be fashioned into a superior $(l:components/assembly#psimetal)$(thing)CAD Assembly$(0)$(/l). It's also used to craft $(l:items/tools)$(thing)Psimetal Tools$(0)$(/l) and $(l:items/exosuit)$(thing)Armor$(0)$(/l), as well as $(l:components/ebony_ivory)$(item)Ebony & Ivory Ingots$(0)$(/l).",
"psi.book.page.psimetal.1": "To create $(item)Psimetal$(0), first drop $(item)Gold Ingots$(0) on the ground.$(p)Then, stand nearby, and cast a $(thing)Spell$(0) with $(piece)Trick: Infusion$(0) (or any other $(piece)infusion trick$(0)) as one of its $(thing)Tricks$(0) to convert the gold into $(item)Psimetal$(0).",
"psi.book.entry.psigem": "Psigem",
"psi.book.page.psigem.0": "$(item)Psigems$(0) are crystals transmuted from $(item)Diamonds$(0) whose refractive properties make them extraordinarily good at conducting, transferring, and storing $(thing)Psi energy$(0).$(p)These are used to fashion top-of-the-line $(l:components/core)$(thing)CAD Cores$(0)$(/l), $(l:components/socket)$(thing)Sockets$(0)$(/l), and $(l:components/battery#ultradense)$(thing)Batteries$(0)$(/l), and as essential components in $(l:items/tools)$(thing)Psimetal Tools$(0)$(/l) and $(l:items/exosuit)$(thing)Armor$(0)$(/l).",
"psi.book.page.psigem.1": "To create a $(item)Psigem$(0), first throw a $(item)Diamond$(0) on the ground.$(p)Then, stand nearby, and cast a $(thing)Spell$(0) with $(piece)Trick: Greater Infusion$(0) (or $(piece)Trick: Ebony & Ivory$(0)) as one of its tricks to convert the $(item)Diamond$(0) into a $(item)Psigem$(0).",
"psi.book.entry.ebonyIvory": "Ebony & Ivory",
"psi.book.page.ebonyIvory.0": "The $(thing)End$(0) is much closer to a dimension of the mind than the $(thing)Overworld$(0). Therefore, its essences are much more conductive to $(thing)Psi energy$(0), which derives from the mind as well.$(p)$(piece)Trick: Ebony & Ivory$(0) can be used to capture these essences in $(item)Coal$(0) and $(item)Nether Quartz$(0), transmuting them into $(item)Ebony Substance$(0) and $(item)Ivory Substance$(0), respectively.",
"psi.book.page.ebonyIvory.1": "Unfortunately, as it turns out, neither $(item)Ebony$(0) nor $(item)Ivory Substance$(0) plays nicely with $(thing)Overworld$(0)-y materials.$(p)This means that fashioning them into $(l:components/core)$(thing)CAD Cores$(0)$(/l), $(l:components/socket)$(thing)Sockets$(0)$(/l), and $(l:components/battery)$(thing)Batteries$(0)$(/l) proves rather difficult.$(p)We $(o)can$(), however, coat $(l:components/psimetal)$(item)Psimetal Ingots$(0)$(/l) with the stuff, yielding $(item)Ebony$(0) and $(item)Ivory Psimetal Ingots$(0), respectively, which are just about stable enough to be shaped into $(l:components/assembly)$(thing)CAD Assemblies$(0)$(/l).",
"psi.book.page.ebonyIvory.2": "To create $(item)Ebony Substance$(0), first travel to the $(thing)End$(0), and drop $(item)Coal$(0) on the ground there.$(p)Then, stand nearby, and cast a $(thing)Spell$(0) with $(piece)Trick: Ebony & Ivory$(0) as one of its $(thing)Tricks$(0) to convert the $(item)Coal$(0) into $(item)Ebony Substance$(0).",
"psi.book.page.ebonyIvory.3": "To create $(item)Ivory Substance$(0), first travel to the $(thing)End$(0), and drop $(item)Nether Quartz$(0) on the ground there.$(p)Then, stand nearby, and cast a $(thing)Spell$(0) with $(piece)Trick: Ebony & Ivory$(0) as one of its $(thing)Tricks$(0) to convert the $(item)Nether Quartz$(0) into $(item)Ivory Substance$(0).",
"psi.book.page.ebonyIvory.4": "Dark'ness Dementia Raven Way",
"psi.book.page.ebonyIvory.5": "No elephants were harmed in its creation",
"psi.book.entry.assembly": "Assemblies",
"psi.book.page.assembly.0": "The $(thing)CAD Assembly$(0) is simple in structure, yet the single most important component of a $(thing)CAD$(0).$(p)An $(thing)Assembly$(0) is responsible for channeling its user's $(thing)Psi energy$(0)-- it's simply a conveniently-shaped conduit for the task.$(p)All $(thing)Psi$(0) $(thing)CADs$(0) are crafted from four ingots of their component material in a crafting grid, shaped in a sideways L.$(p)",
"psi.book.page.assembly.1": "The $(thing)Assembly$(0) is the only $(thing)CAD$(0) component that's strictly necessary in an $(l:basics/cad_assembler)$(item)CAD Assembler$(0)$(/l)-- indeed, any $(thing)CAD$(0) consisting of just an $(thing)Assembly$(0) can be reverted to one in a crafting grid.$(p)Every $(thing)Assembly$(0) has a $(l:basics/tutorial_5#potency)$(thing)Potency$(0)$(/l): roughly, the maximum rate it can channel $(thing)Psi energy$(0) at.$(p)It also has an $(l:basics/tutorial_5#cost)$(thing)Efficiency$(0)$(/l), which is the percent of its user's $(thing)Psi energy$(0) that it can actually $(o)use$() in a $(thing)Spell$(0)-- a higher $(l:basics/tutorial_5#cost)$(thing)Efficiency$(0)$(/l) is better.",
"psi.book.page.assembly.2": "The humble $(item)Iron CAD Assembly$(0) has the lowest $(l:basics/tutorial_5#potency)$(thing)Potency$(0)$(/l) and $(l:basics/tutorial_5#cost)$(thing)Efficiency$(0)$(/l) of any $(thing)Assembly$(0) in this book.$(p)But it's relatively cheap, and crafts $(l:components/psidust)$(item)Psidust$(0)$(/l) as well any other $(thing)CAD$(0), so it's the go-to $(thing)Assembly$(0) for beginners.",
"psi.book.page.assembly.3": "Sleek and simple",
"psi.book.page.assembly.4": "The $(item)Gold CAD Assembly$(0) boasts a higher $(l:basics/tutorial_5#potency)$(thing)Potency$(0)$(/l) as well as a higher $(l:basics/tutorial_5#cost)$(thing)Efficiency$(0)$(/l) than its iron counterpart-- in fact, it's the best $(thing)Assembly$(0) in the book that's made from mundane materials.",
"psi.book.page.assembly.5": "A bit heavy to carry around, though",
"psi.book.page.assembly.6": "The $(item)Psimetal CAD Assembly$(0) has a higher $(l:basics/tutorial_5#cost)$(thing)Efficiency$(0)$(/l) than an $(l:components/assembly#iron)$(item)Iron Assembly$(0)$(/l) as well as a higher $(l:basics/tutorial_5#potency)$(thing)Potency$(0)$(/l) than a $(l:components/assembly#gold)$(item)Gold Assembly$(0)$(/l), making it versatile indeed.$(p)Both $(piece)Trick: Greater Infusion$(0) and $(piece)Trick: Ebony & Ivory$(0) require a $(thing)CAD$(0) with an $(thing)Assembly$(0) of this caliber or higher to cast.",
"psi.book.page.assembly.7": "Best of both worlds",
"psi.book.page.assembly.8": "The $(item)Ebony Psimetal CAD Assembly$(0) is a top-tier type of $(item)Assembly.$(0)$(p)It's slightly less efficient, but can handle more $(l:basics/tutorial_5#potency)$(thing)Potency$(0)$(/l), than its $(l:components/assembly#ivory)$(item)Ivory$(0)$(/l) counterpart.",
"psi.book.page.assembly.9": "The big guns (so to speak)",
"psi.book.page.assembly.10": "The $(item)Ivory Psimetal CAD Assembly$(0) is a top-tier type of $(item)Assembly.$(0)$(p)It's slightly less potent, but has a greater $(l:basics/tutorial_5#cost)$(thing)Efficiency$(0)$(/l), than its $(l:components/assembly#ebony)$(item)Ebony$(0)$(/l) counterpart.",
"psi.book.page.assembly.11": "Go with the flow",
"psi.book.entry.core": "Cores",
"psi.book.page.core.0": "A $(thing)CAD$(0)'s $(thing)Core$(0) is essentially its CPU-- it's responsible for reading a $(thing)Spell$(0) from the $(l:components/socket)$(thing)Socket$(0)$(/l), running calculations, and using $(thing)Psi energy$(0) to create the effects of $(thing)Tricks$(0) in the world.$(p)$(thing)CAD Cores$(0) are crafted with four of a $(thing)Psi$(0)-conductive material placed around a central piece of dust (as a processor).",
"psi.book.page.core.1": "Every $(thing)CAD Core$(0) has a $(l:basics/tutorial_5#complexity)$(thing)Complexity$(0)$(/l), which is the maximum number of computations ($(thing)Selectors$(0), $(thing)Operators$(0), non-debug $(thing)Tricks$(0)) the $(thing)Core$(0) can perform per-$(thing)Spell$(0).$(p)A $(thing)Core$(0) also has a $(l:basics/tutorial_5#projection)$(thing)Projection$(0)$(/l), which is simply the total number of non-debug $(thing)Tricks$(0) it can perform at once.",
"psi.book.page.core.2": "Crafted from an $(item)Iron$(0) shell around a piece of $(l:components/psidust)$(item)Psidust$(0)$(/l), the $(item)Basic CAD Core$(0) is often the first $(thing)CAD Core$(0) a mage crafts.$(p)It's not fantastic (in particular, it can only cast one $(thing)Trick$(0) at a time), but it's quite sufficient for a beginner's needs.",
"psi.book.page.core.3": "Spell it out",
"psi.book.page.core.4": "Substituting $(l:components/psimetal)$(item)Psimetal$(0)$(/l) for $(item)Iron$(0) around a $(thing)CAD Core$(0) allows us to use a different dust component in the $(thing)Core$(0)'s center.$(p)If $(item)Redstone Dust$(0) is used for the dust, we get a $(item)Overclocked CAD Core$(0), which boasts twice the $(l:basics/tutorial_5#complexity)$(thing)Complexity$(0)$(/l) of its $(l:components/core#basic)$(item)Basic$(0)$(/l) predecessor, and thrice the $(l:basics/tutorial_5#projection)$(thing)Projection$(0)$(/l).",
"psi.book.page.core.5": "A hat trick",
"psi.book.page.core.6": "If, instead, we place a piece of $(item)Glowstone Dust$(0) within a $(l:components/psimetal)$(item)Psimetal$(0)$(/l) shell, we create a $(item)Conductive CAD Core$(0).$(p)This $(thing)Core$(0) handles less $(l:basics/tutorial_5#complexity)$(thing)Complexity$(0)$(/l) than its $(item)Redstone Dust$(0)-based counterpart, but can handle four $(thing)Tricks$(0) at once, over the $(l:components/core#overclocked)$(item)Overclocked$(0)$(/l)'s three.",
"psi.book.page.core.7": "Some real tricky business",
"psi.book.page.core.8": "Embedding two $(l:components/psigem)$(item)Psigems$(0)$(/l) into the recipe for a $(thing)CAD Core$(0) creates $(o)serious$() performance benefits.$(p)The $(item)Hyperclocked CAD Core$(0), with $(item)Redstone Dust$(0) at its center, has double the $(l:basics/tutorial_5#complexity)$(thing)Complexity$(0)$(/l) of a $(l:components/core#conductive)$(item)Conductive$(0)$(/l) core $(o)and$() double the $(l:basics/tutorial_5#projection)$(thing)Projection$(0)$(/l) of an $(l:components/core#overclocked)$(item)Overclocked$(0)$(/l) one.",
"psi.book.page.core.9": "Won't tell the time, though",
"psi.book.page.core.10": "If we use $(l:components/psigem)$(item)Psigems$(0)$(/l) in a $(thing)CAD Core$(0) with $(item)Glowstone Dust$(0) at its center, we get a $(item)Radiative CAD Core$(0).$(p)This $(thing)Core$(0) has a lesser $(l:basics/tutorial_5#projection)$(thing)Projection$(0)$(/l) than the $(l:components/core#hyperclocked)$(item)Hyperclocked$(0)$(/l) one, but has the capability to execute a staggering $(o)seven$() $(thing)Tricks$(0) per-cast.",
"psi.book.page.core.11": "No technetium involved",
"psi.book.entry.socket": "Sockets",
"psi.book.page.socket.0": "A $(thing)CAD$(0)'s $(thing)Socket$(0) is basically its bullet clip.$(p)It's what $(l:items/spell_bullet)$(thing)Spell Bullets$(0)$(/l) are loaded into, and it's responsible for transferring the compiled $(thing)Spells$(0) contained within the $(l:items/spell_bullet)$(thing)Bullets$(0)$(/l) to the $(l:components/core)$(thing)Core$(0)$(/l) for processing.$(p)$(thing)Sockets$(0) are crafted with a piece of dust, which interfaces with the $(l:items/spell_bullet)$(thing)Bullets$(0)$(/l), on a metallic substrate.",
"psi.book.page.socket.1": "A $(thing)Socket$(0) has a $(l:basics/tutorial_5#bandwidth)$(thing)Bandwidth$(0)$(/l), which is the maximum size (in grid spaces) of a $(thing)Spell$(0) that it can transfer to a $(l:components/core)$(thing)Core$(0)$(/l), all at once-- for example, a $(thing)Socket$(0) with bandwidth 5 could transfer a $(thing)Spell$(0) up to 5x5 in dimension.$(p)It also has, well, a number of $(thing)Sockets$(0), which are compartments that can hold one $(l:items/spell_bullet)$(thing)Spell Bullet$(0)$(/l) each.",
"psi.book.page.socket.2": "The $(item)Basic CAD Socket$(0) is the simplest of $(thing)Sockets$(0), crafted from $(l:components/psidust)$(item)Psidust$(0)$(/l) on a substrate of $(item)Iron$(0).$(p)It holds up to four $(l:items/spell_bullet)$(thing)Spell Bullets$(0)$(/l) at a time, and can transfer $(thing)Spells$(0) up to 5x5 in size.",
"psi.book.page.socket.3": "Plug & chug",
"psi.book.page.socket.4": "Replacing the $(item)Iron$(0) substrate in a $(thing)Socket$(0) with a metal that's more conductive to $(thing)Psi energy$(0) (i.e. $(l:components/psimetal)$(item)Psimetal$(0)$(/l)) allows us to choose a different dust to interface with the $(l:items/spell_bullet)$(thing)Spell Bullets$(0)$(/l).$(p)Using $(item)Redstone Dust$(0) gets us a $(item)Signaling CAD Socket$(0), which holds up to six $(l:items/spell_bullet)$(thing)Bullets$(0)$(/l), each with a $(thing)Spell$(0) up to 7x7 in size.",
"psi.book.page.socket.5": "Perfect for Russian Roulette",
"psi.book.page.socket.6": "Placing $(item)Glowstone Dust$(0) on a $(l:components/psimetal)$(item)Psimetal$(0)$(/l) substrate creates a $(item)Large CAD Socket$(0).$(p)This $(thing)Socket$(0) can't handle $(thing)Spells$(0) as large as its $(l:components/socket#signaling)$(item)Signaling$(0)$(/l) counterpart can, only managing those up to 6x6 in size, but can hold up to eight $(l:items/spell_bullet)$(thing)Bullets$(0)$(/l) at a time.",
"psi.book.page.socket.7": "Practically endless",
"psi.book.page.socket.8": "Augmenting a $(thing)Socket$(0) in its recipe with a $(l:components/psigem)$(item)Psigem$(0)$(/l) makes it transfer a lot more data, a lot faster.$(p)A $(l:components/socket#signaling)$(item)Signaling CAD Socket$(0)$(/l) with such an augmentation becomes a $(item)Transmissive CAD Socket$(0), which can hold up to ten $(l:items/spell_bullet)$(thing)Bullets$(0)$(/l), and can in fact handle $(o)any$() $(thing)Spell$(0) that fits in a $(l:basics/spell_programmer)$(item)Spell Programmer$(0)$(/l).",
"psi.book.page.socket.9": "Avaritia's Bane",
"psi.book.page.socket.10": "A $(l:components/socket#large)$(item)Large CAD Socket$(0)$(/l), augmented with a $(l:components/psigem)$(item)Psigem$(0)$(/l), becomes the imaginatively-named $(item)Huge CAD Socket$(0).$(p)One of these doesn't have the $(l:basics/tutorial_5#bandwidth)$(thing)Bandwidth$(0)$(/l) of its $(l:components/socket#transmissive)$(item)Transmissive$(0)$(/l) counterpart (only $(thing)Spells$(0) that are 8x8 or smaller), but can store up to a full dozen $(l:items/spell_bullet)$(thing)Spell Bullets$(0)$(/l).",
"psi.book.page.socket.11": "Hope Ophiuchus doesn't mind",
"psi.book.entry.battery": "Batteries",
"psi.book.page.battery.0": "A $(thing)CAD Battery$(0) is an optional attachment to a $(thing)CAD$(0), allowing it to indefinitely store a small amount of its user's $(thing)Psi energy$(0)-- its $(thing)Overflow$(0) represents how much.$(p)A $(thing)Battery$(0) discharges after its user's main supply of $(thing)Psi energy$(0) runs out, but before the $(thing)CAD$(0) taps into its user's health.",
"psi.book.page.battery.1": "In effect, a $(thing)Battery$(0) is meant to be a small safety net of stored $(thing)Psi energy$(0).$(p)It's there so that you can overdraw a $(o)bit$(), without taking damage or having to wait for your $(thing)Psi energy$(0) to refill.$(p)All $(thing)Batteries$(0) are crafted with a $(thing)Psi energy$(0)-conductive material enclosed between an $(item)Iron$(0) and a $(item)Gold Ingot$(0).$(p)A $(thing)Battery$(0)'s current charge can be accessed from a $(thing)Spell$(0) with $(piece)Selector: Caster Battery$(0).",
"psi.book.page.battery.2": "Not lithium-ion",
"psi.book.page.battery.3": "It's pretty metal",
"psi.book.page.battery.4": "Call 1-(800)-BATTERY",
"psi.book.entry.colorizer": "Colorizers",
"psi.book.page.colorizer.0": "A $(thing)CAD Colorizer$(0) is an optional attachment to a $(thing)CAD$(0) that modifies the color of its user's $(thing)Psi energy$(0) as it manifests in the physical world.$(p)All $(thing)Colorizers$(0) are crafted with a base of an $(item)Iron Ingot$(0), a piece of $(l:components/psidust)$(item)Psidust$(0)$(/l) on top, two pieces of $(item)Glass$(0) (one on either side), and of course a color item to apply in the center. ",
"psi.book.page.colorizer.1": "A $(thing)Colorizer$(0) can be crafted with any of the sixteen vanilla $(item)Dyes$(0) for their respective colors.$(p)If $(item)Prismarine Crystals$(0) are used in place of a dye, the resulting $(thing)Colorizer$(0) will shift through the colors of the rainbow.$(p)If, on the other hand, $(o)no$() color item is used, the resulting $(thing)Colorizer$(0) will $(o)draw$() color $(o)out$() of the user's $(thing)Psi energy$(0), and the resulting particles will be nigh-invisible.",
"psi.book.page.colorizer.2": "Using a piece of $(l:components/psidust)$(item)Psidust$(0)$(/l) as the color item in the $(thing)Colorizer$(0) seems to have no known effect for most people, though certain individuals have reported differently.$(p)A $(thing)Colorizer$(0) in a $(thing)CAD$(0) affects:$(p)$(li)particles emitted by the $(thing)CAD$(0);$(p)$(li)projectiles and $(l:items/circle_bullet)$(thing)Spell Circles$(0)$(/l) cast;$(p)$(li)blocks and lights conjured by the $(piece)conjuration tricks$(0).",
"psi.book.page.colorizer.3": "Taste the Rainbow",
"psi.book.category.items": "Items",
"psi.book.category.items.desc": "This section is filled to the brim with all sorts of items, tools, and utilities you can use to enhance your $(thing)Spell$(0)-casting experience.",
"psi.book.entry.spellBullet": "Spell Bullet Types",
"psi.book.page.spellBullet.0": "A $(thing)Spell Bullet$(0) is a simple device-- when inserted into a $(thing)CAD$(0)'s $(l:components/socket)$(thing)Socket$(0)$(/l), it simply provides its contained $(thing)Spell$(0)'s data (and metadata) to the $(thing)CAD$(0).$(p)But $(thing)Bullets$(0) come in several types, each with their own merits.$(p)Each entry linked on the next page has more detailed information on that type of $(thing)Bullet$(0).",
"psi.book.page.spellBullet.1": "If you want a specific type of $(thing)Spell Bullet$(0), here you go.",
"psi.book.page.spellBullet.2": "Every type of $(thing)Spell Bullet$(0) is crafted with an $(item)Iron Ingot$(0) and a piece of $(l:components/psidust)$(item)Psidust$(0)$(/l), horizontally placed in a crafting grid.$(p)If nothing else is added to the recipe, this yields the most basic type of $(thing)Spell Bullet$(0), (somewhat confusingly) just called the $(l:items/basic_bullet)$(item)Spell Bullet$(0)$(/l).$(p)Other types of $(thing)Spell Bullet$(0) require one more ingredient, placed horizontally adjacent to the $(item)Iron Ingot$(0).",
"psi.book.page.spellBullet.3": "The ingredients for other types of $(thing)Spell Bullets$(0) are as follows:$(p)$(li)a $(l:items/projectile_bullet)$(item)Projectile Spell Bullet$(0)$(/l) needs some kind of $(item)Arrow$(0),$(p)$(li)a $(l:items/loopcast_bullet)$(item)Loopcast Spell Bullet$(0)$(/l) needs a piece of $(item)String$(0),$(p)$(li)a $(l:items/circle_bullet)$(item)Circle Spell Bullet$(0)$(/l) needs, well, something circular (a $(item)Snowball$(0) or a $(item)Slimeball$(0)),$(p)$(li)a $(l:items/grenade_bullet)$(item)Grenade Spell Bullet$(0)$(/l) needs a piece of $(item)Gunpowder$(0),$(p)$(li)a $(l:items/charge_bullet)$(item)Charge Spell Bullet$(0)$(/l) needs a piece of $(item)Redstone Dust$(0), and$(p)$(li)a $(l:items/mine_bullet)$(item)Mine Spell Bullet$(0)$(/l) needs some kind of $(item)Button$(0).",
"psi.book.page.spellBullet.4": "Before a $(thing)Spell Bullet$(0) can be loaded into a $(thing)CAD$(0), it needs to have a $(thing)Spell$(0) stored on it.$(p)To store a $(thing)Spell$(0) on a $(l:basics/spell_programmer)$(item)Spell Programmer$(0)$(/l) in a $(thing)Bullet$(0), just swipe the $(thing)Spell Bullet$(0) over the $(l:basics/spell_programmer)$(item)Programmer$(0)$(/l) ($(k:use)).$(p)A $(thing)Spell$(0) stored in a $(thing)Spell Bullet$(0) can be copied into an empty $(l:items/spell_drive)$(item)Spell Drive$(0)$(/l) in a crafting grid for storage purposes.",
"psi.book.page.spellBullet.5": "A $(l:basics/spell_programmer)$(item)Spell Programmer$(0)$(/l) displays a $(l:basics/tutorial_5#cost)$(thing)Cost$(0)$(/l) for any $(thing)Spell$(0) it compiles successfully-- yet for different types of $(thing)Bullets$(0), this $(l:basics/tutorial_5#cost)$(thing)Cost$(0)$(/l) can be different.$(p)The $(l:basics/spell_programmer)$(item)Programmer$(0)$(/l)'s value is calibrated to the most basic type of $(thing)Spell Bullet$(0), (somewhat confusingly) just called the $(l:items/basic_bullet)$(item)Spell Bullet$(0)$(/l).",
"psi.book.page.spellBullet.6": "All other types of $(thing)Spell Bullet$(0) display a $(thing)Cost Multiplier$(0) in percentage, which can simply be multiplied by the cost displayed on the $(l:basics/spell_programmer)$(item)Programmer$(0)$(/l) to determine the $(thing)Spell$(0)'s true $(l:basics/tutorial_5#cost)$(thing)Cost$(0)$(/l) for that $(thing)Bullet$(0) type.$(p)For example, if a $(thing)Spell$(0) displays a final cost of 300 in a $(l:basics/spell_programmer)$(item)Programmer$(0)$(/l), when copied into a $(l:items/projectile_bullet)$(item)Projectile Spell Bullet$(0)$(/l) (with a $(thing)Cost Multiplier$(0) of 102%%) it would have a true $(l:basics/tutorial_5#cost)$(thing)Cost$(0)$(/l) of$(br)300 \u00d7 102%% = 306 $(thing)Psi energy$(0) per cast.",
"psi.book.page.spellBullet.7": "Many $(thing)Spell Bullet$(0) types introduce a delay between when the $(thing)Spell$(0) is cast, and when it actually gets executed.$(p)Thus, it's important to note that the $(l:basics/tutorial_5#cost)$(thing)Cost$(0)$(/l) of a $(thing)Spell$(0) being cast is paid upfront in full, and is non-refundable-- even if the $(thing)Tricks$(0) in the $(thing)Spell$(0) don't actually get cast.",
"psi.book.page.spellBullet.8": "Every $(thing)Spell$(0), when cast, has a $(thing)Focal Point$(0).$(p)A $(thing)Focal Point$(0) is where the caster's $(thing)Psi energy$(0) is projected into the world (as one or more $(thing)Tricks$(0)).$(p)Of course, a $(thing)Focal Point$(0) can't execute any $(thing)Tricks$(0) or evaluate any $(thing)Selectors$(0) from further than 32 blocks away (excepting those that affect its caster).$(p)A $(thing)Spell$(0) can access its $(thing)Focal Point$(0) using $(piece)Selector: Focal Point$(0).",
"psi.book.page.spellBullet.9": "The location of a $(thing)Focal Point$(0) depends on the type of $(thing)Spell Bullet$(0) it's cast from.$(p)The basic $(l:items/basic_bullet)$(item)Spell Bullet$(0)$(/l)'s $(thing)Focal Point$(0) is simply the caster of the $(thing)Spell$(0), but other types of $(l:items/basic_bullet)$(item)Spell Bullet$(0)$(/l) can create different $(thing)Focal Points$(0).$(p)For example, a $(l:items/projectile_bullet)$(item)Projectile Spell Bullet$(0)$(/l)'s $(thing)Focal Point$(0) is the projectile itself.$(p)For more info on each $(thing)Bullet$(0) type's $(thing)Focal Points$(0) and quirks, consult individual entries.",
"psi.book.entry.basicBullet": "Spell Bullet",
"psi.book.page.basicBullet.0": "The simplest type of $(l:items/spell_bullet)$(thing)Spell Bullet$(0)$(/l) (and the namesake of the line of items), the humble $(item)Spell Bullet$(0) stores a $(thing)Spell$(0).$(p)When a $(thing)Spell$(0) stored in it is cast, it executes right away. The $(l:items/spell_bullet#focal_point)$(thing)Focal Point$(0)$(/l) for this type of $(l:items/spell_bullet)$(thing)Bullet$(0)$(/l) is just the caster. Its cost of casting is exactly what the $(l:basics/spell_programmer)$(item)Spell Programmer$(0)$(/l) says it is.$(p)No funny business here.",
"psi.book.page.basicBullet.1": "No gunpowder necessary",
"psi.book.entry.projectileBullet": "Projectile Spell Bullet",
"psi.book.page.projectileBullet.0": "A $(thing)Spell$(0) cast from a $(item)Projectile Spell Bullet$(0) doesn't execute immediately.$(p)Instead, a fast-moving $(thing)Spell Projectile$(0) containing it is fired out the end of the $(thing)CAD$(0) from which it's cast.$(p)This projectile acts as the $(l:items/spell_bullet#focal_point)$(thing)Focal Point$(0)$(/l) for its $(thing)Spell$(0), executing it when the projectile collides with something.",
"psi.book.page.projectileBullet.1": "Not quite high noon",
"psi.book.page.projectileBullet.2": "A $(thing)Spell Projectile$(0) isn't physical; instead, it's a thin wrapper of $(thing)Psi energy$(0) around its contained $(thing)Spell$(0) (hence the extra cost in the $(l:items/spell_bullet)$(thing)Bullet$(0)$(/l)).$(p)As such, it can last for up to thirty seconds before dissipating.$(p)A $(thing)Spell Projectile$(0) moves quite swiftly, and can travel more than 200 blocks' distance without assistance in its lifespan.",
"psi.book.page.projectileBullet.3": "The projectile's stored $(thing)Spell$(0) will activate if it collides with any blocks or entities.$(p)In the case of the latter, $(piece)Selector: Attack Target$(0) can be used to identify the entity that was hit.$(p)On the other hand, if the projectile hits $(o)nothing$() in that time, the $(thing)Spell$(0) will fizzle, wasting the $(thing)Psi energy$(0) invested into it-- so aim carefully!",
"psi.book.entry.loopcastBullet": "Loopcast Spell Bullet",
"psi.book.page.loopcastBullet.0": "A $(thing)Spell$(0) cast from a $(item)Loopcast Spell Bullet$(0) is executed as if from a plain $(l:items/basic_bullet)$(item)Spell Bullet$(0)$(/l).$(p)Repeatedly.$(p)A $(thing)Spell$(0) cast from one of these $(l:items/spell_bullet)$(thing)Bullets$(0)$(/l) is executed over and over nonstop, four times a second, until the $(thing)CAD$(0) it was cast from stops being held in the same hand, or a different $(thing)Spell$(0) is selected.",
"psi.book.page.loopcastBullet.1": "The definition of insanity",
"psi.book.page.loopcastBullet.2": "The $(l:items/spell_bullet#focal_point)$(thing)Focal Point$(0)$(/l) for a $(thing)Spell$(0) cast from a $(item)Loopcast Spell Bullet$(0) is just the caster, and the full $(thing)Psi energy$(0) cost is incurred on each execution.$(p)The major advantage of using one of these $(l:items/spell_bullet)$(thing)Bullets$(0)$(/l) over just casting repeatedly really fast lies in the $(o)regeneration$() of your $(thing)Psi energy$(0).",
"psi.book.page.loopcastBullet.3": "When you cast a $(thing)Spell$(0) (or when you take damage), your $(thing)Psi energy$(0) is momentarily left in a state of disequilibrium; it can't regenerate until you can focus inward and restabilize it.$(br)While not difficult, this restabilization takes a bit of time to achieve.$(p)But when you cast from a $(item)Loopcast Spell Bullet$(0), this delay only occurs $(o)initially$()-- afterwards, the $(l:items/spell_bullet)$(thing)Bullet$(0)$(/l) makes no disruptions in your $(thing)Psi energy$(0), allowing it to regenerate as normal.",
"psi.book.page.loopcastBullet.4": "A $(thing)Spell$(0) cast from one of these $(l:items/spell_bullet)$(thing)Bullets$(0)$(/l) can do different things on each invocation.$(p)Specifically, $(piece)Selector: Loopcast Index$(0) returns the number of times the $(thing)Spell$(0) has been executed since you first cast it.$(p)Thus, it returns 1 the first time the $(thing)Spell$(0) executes, 2 the second time, and so on.",
"psi.book.page.loopcastBullet.5": "When used with $(piece)Operator: Integer Divide$(0) and $(piece)Operator: Modulus$(0), these $(l:items/spell_bullet)$(thing)Bullets$(0)$(/l) can perform operations $(o)en masse$() over wide areas with ease.",
"psi.book.entry.circleBullet": "Circle Spell Bullet",
"psi.book.page.circleBullet.0": "A $(thing)Spell$(0) cast from a $(item)Circle Spell Bullet$(0) is executed consecutively exactly twenty times.$(p)When the $(thing)Spell$(0) is first cast, a $(thing)Spell Circle$(0) is conjured at the point the caster is looking at, which acts as the $(l:items/spell_bullet#focal_point)$(thing)Focal Point$(0)$(/l) for the $(thing)Spell$(0). This circle executes the $(thing)Spell$(0) four times a second until it runs out of $(thing)Psi energy$(0), five seconds later.",
"psi.book.page.circleBullet.1": "The Costco of spellslinging",
"psi.book.page.circleBullet.2": "A $(thing)Spell Circle$(0), when first cast, is conjured up to 32 blocks away from the caster's position or at the nearest block they look at (whichever is closer).$(p)Similarly to a $(l:items/loopcast_bullet)$(item)Loopcast Spell Bullet$(0)$(/l), a $(thing)Spell$(0) cast from a $(thing)Spell Circle$(0) can know which iteration it's on using $(piece)Selector: Loopcast Index$(0) (which will return a number from 1 to 20, inclusive).",
"psi.book.page.circleBullet.3": "A $(thing)Spell Circle$(0) drains all the $(thing)Psi energy$(0) it needs when it's first cast, hence its $(thing)Cost Multiplier$(0) of a whopping 1500%%.$(p)However, its voracious $(l:basics/tutorial_5#cost)$(thing)Cost$(0)$(/l) is not without benefit; its compact, self-contained design makes it $(o)extremely$() efficient, allowing it to execute a $(thing)Spell$(0) 20 times for the cost of 15.$(p)For those of you keeping track, that's a full 25%% discount per-execution.",
"psi.book.page.circleBullet.4": "$(item)Circle Spell Bullets$(0) are popular among spellslingers new and experienced both for their versatility and their conservation of $(thing)Psi energy$(0).$(p)As such, there are several relatively common $(thing)Tricks$(0) used with $(item)Circle Spell Bullets$(0) in particular that aren't seen elsewhere.",
"psi.book.page.circleBullet.5": "The $(thing)Circlesync$(0) idiom, relatively simple to build, allows all twenty executions of the $(thing)Spell$(0) to happen at once, allowing them to accumulate into a much grander effect than a single execution would alone.$(p)The $(thing)20-Bit Tower$(0) idiom has a slightly more difficult setup involving a $(l:items/vector_ruler)$(item)Vector Ruler$(0)$(/l); but allows a $(thing)Spell$(0) to only do something on a subset of its twenty executions.",
"psi.book.subsec.circleBullet.6": "Circlesync",
"psi.book.page.circleBullet.6": "The $(thing)Circlesync$(0) idiom (pictured at right) uses $(piece)Trick: Sleep$(0) at its core.$(p)When placed in the $(thing)Spell$(0), it delays each execution corresponding exactly to the time left until the final $(thing)Trick$(0) activates.$(p)Any $(thing)Tricks$(0) placed after the $(piece)Trick: Sleep$(0), then, execute simultaneously.",
"psi.book.page.circleBullet.7": "When the stars align... ",
"psi.book.subsec.circleBullet.8": "20-Bit Tower",
"psi.book.page.circleBullet.8": "The $(thing)20-Bit Tower$(0) idiom is a rather advanced technique, rather technical in design.$(p)To use it, select a block with a $(l:items/vector_ruler)$(item)Vector Ruler$(0)$(/l), then place some blocks (it doesn't matter what kind) in the twenty-block-high vertical space directly above the location you selected, then copy the code on the following page to the top of your $(thing)Spell$(0).",
"psi.book.page.circleBullet.9": "Each block position in that vertical space represents one execution of the $(thing)Spell$(0); the bottommost location of the tower represents the first execution, the next location the second, and so on.$(p)An empty space in a tower represents "$(o)DO$() execute on that iteration," and a block in that position tells the $(thing)Spell$(0) "$(o)DON'T$()."$(p)Finally, copy the code on the next page to the top of your $(thing)Spell$(0).",
"psi.book.page.circleBullet.10": "Conditionally",
"psi.book.entry.grenadeBullet": "Grenade Spell Bullet",
"psi.book.page.grenadeBullet.0": "A $(thing)Spell$(0) cast from a $(item)Grenade Spell Bullet$(0), instead of executing immediately, is fired out the end of the $(thing)CAD$(0) it was cast in a $(thing)Spell Grenade$(0).$(p)Unlike a $(l:items/projectile_bullet)$(thing)Spell Projectile$(0)$(/l), though, a grenade $(o)is$() affected by gravity.$(p)It executes its contained $(thing)Spell$(0) after exactly three seconds, no sooner and no later.",
"psi.book.page.grenadeBullet.1": "Pull the trigger, not the pin",
"psi.book.page.grenadeBullet.2": "A $(thing)Spell Grenade$(0) is an intangible thin wrapper of $(thing)Psi energy$(0), created from the excess drawn by the $(item)Grenade Spell Bullet$(0).$(p)The conjured grenade also acts as the $(l:items/spell_bullet#focal_point)$(thing)Focal Point$(0)$(/l) for the $(thing)Spell$(0) when it executes.$(p)While its uses appear rather limited at first, a $(thing)Spell Grenade$(0) can reach places a $(l:items/projectile_bullet)$(thing)Spell Projectile$(0)$(/l) can't (e.g. over a wall, or inside a hole).",
"psi.book.page.grenadeBullet.3": "A $(thing)Spell Grenade$(0) will record the last entity it comes into contact with.$(p)When its contained $(thing)Spell$(0) executes, this entity can be accessed from $(piece)Selector: Attack Target$(0), if applicable.",
"psi.book.entry.chargeBullet": "Charge Spell Bullet",
"psi.book.page.chargeBullet.0": "A $(thing)Spell$(0) cast from a $(item)Charge Spell Bullet$(0), rather than executing immediately, is fired out the end of the $(thing)CAD$(0) it's cast from in a $(thing)Spell Charge$(0), which obeys gravity just like a $(l:items/grenade_bullet)$(thing)Spell Grenade$(0)$(/l).$(p)However, unlike a $(l:items/grenade_bullet)$(thing)Spell Grenade$(0)$(/l), a $(thing)Spell Charge$(0) can last up to five minutes, and only executes its $(thing)Spell$(0) when specially told to do so by a $(l:items/detonator)$(item)Spell Detonator$(0)$(/l).",
"psi.book.page.chargeBullet.1": "They build up",
"psi.book.page.chargeBullet.2": "A $(thing)Spell Charge$(0) is a stable shell of $(thing)Psi energy$(0) around its contained $(thing)Spell$(0), acting as the $(thing)Spell$(0)'s $(l:items/spell_bullet#focal_point)$(thing)Focal Point$(0)$(/l) when executed.$(p)If the $(thing)Spell Charge$(0) is never activated within its lifetime, it simply dissipates, fizzling the $(thing)Spell$(0) within and wasting the invested $(thing)Psi energy$(0).",
"psi.book.page.chargeBullet.3": "However, many $(thing)Spell Charges$(0) in close proximity can all be activated at once by a single $(l:items/detonator)$(item)Spell Detonator$(0)$(/l) (or $(piece)Trick: Detonate$(0)), making them quite useful for mass effect.$(p)A $(thing)Spell Charge$(0) will record the last entity it bumps into (or, as may occur, the last entity to step on it).$(p)When its contained $(thing)Spell$(0) executes, this entity can be accessed from $(piece)Selector: Attack Target$(0), if applicable.",
"psi.book.entry.mineBullet": "Mine Spell Bullet",
"psi.book.page.mineBullet.0": "A $(thing)Spell$(0) cast from a $(item)Mine Spell Bullet$(0) is fired out of the $(thing)CAD$(0) it was cast in a $(thing)Spell Mine$(0).$(p)A $(thing)Spell Mine$(0) obeys gravity and has a five-minute lifespan, and only executes its stored $(thing)Spell$(0) once stepped on by someone (or something).",
"psi.book.page.mineBullet.1": "Country roads...",
"psi.book.page.mineBullet.2": "A $(thing)Spell Mine$(0)'s conditions for execution are rather finicky; a mine begins by staying on the ground and waiting to be stepped on.$(p)When one or more entities step on it, the mine doesn't trigger right away; instead it merely primes itself.$(p)When it's primed and there are no longer any entities atop it, then and only then will it execute its contained $(thing)Spell$(0).",
"psi.book.page.mineBullet.3": "The entity that triggered the $(thing)Spell$(0) (i.e. the last entity to step off the $(thing)Spell Mine$(0)) is accessible from $(piece)Selector: Attack Target$(0).$(p)However, if a $(thing)Spell Mine$(0)'s activation conditions are never met within its lifetime, the mine will simply dissipate, fizzling its stored energy.$(p)So if you end up landing on a $(thing)Spell Mine$(0), waiting it out might just be preferable to knowing what the caster has in store for you.",
"psi.book.entry.detonator": "Spell Detonator",
"psi.book.page.detonator.0": "A $(item)Spell Detonator$(0) is crafted from two $(item)Iron Ingots$(0), $(l:components/psidust)$(item)Psidust$(0)$(/l), and a $(item)Button$(0).$(p)It serves exactly one function: when it's actuated ($(k:use)), it activates every single $(l:items/charge_bullet)$(thing)Spell Charge$(0)$(/l) (and $(l:items/exosuit_sensor#trigger)$(item)Exosuit Detonation Sensor$(0)$(/l)) cast by you in a 32-block radius, instructing them to simultaneously execute their contained $(thing)Spells$(0).",
"psi.book.page.detonator.1": "The first bomb",
"psi.book.entry.exosuit": "Psimetal Exosuit",
"psi.book.page.exosuit.0": "A $(thing)Psimetal Exosuit$(0) is a suit of armor allowing you to seamlessly integrate $(thing)Spell$(0)-casting into your everyday adventuring!$(p)Each piece of the $(thing)Exosuit$(0) is crafted from two $(l:components/psigem)$(item)Psigems$(0)$(/l) and some $(l:components/psimetal)$(item)Psimetal$(0)$(/l), and is capable of casting a $(thing)Spell$(0) when its respective trigger is activated.",
"psi.book.page.exosuit.1": "The suits' $(thing)Spells$(0) are cast with your $(thing)CAD$(0) as a focus, so the usual $(thing)CAD$(0) limits apply.$(p)Each piece of the $(thing)Psimetal Exosuit$(0) can be loaded with up to three $(l:items/spell_bullet)$(thing)Spell Bullets$(0)$(/l) in a $(l:basics/cad_assembler)$(item)CAD Assembler$(0)$(/l), though sadly, some $(l:items/spell_bullet)$(thing)Spell Bullet$(0)$(/l) variants don't play well with the suit.$(p)A suit piece remembers the number of times it's successfully cast a $(thing)Spell$(0); this count can be accessed from $(piece)Selector: Success Counter$(0).",
"psi.book.page.exosuit.2": "To select which $(thing)Spell$(0) to use for a suit piece, craft an $(item)Exosuit Controller$(0) from $(item)Redstone Dust$(0), $(item)Glass$(0), and $(l:components/psimetal)$(item)Psimetal$(0)$(/l). To use the $(item)Controller$(0), hold the $(thing)Psi master keybind$(0) ($(k:psimisc.keybind)).$(p)Use the right and left-mouse buttons to cycle through suit pieces.",
"psi.book.page.exosuit.3": "It's no JARVIS, but it works",
"psi.book.page.exosuit.4": "Once you've selected the suit piece you want to configure, choose one of the $(l:items/spell_bullet)$(thing)Spell Bullets$(0)$(/l) that's displayed the same way you would with your $(thing)CAD$(0).$(p)Selecting the empty fourth slot disables that suit piece completely-- no $(thing)Spells$(0) will be cast even if its activation criteria are met.",
"psi.book.page.exosuit.5": "A $(thing)Psimetal Exosuit$(0) is slightly better than $(thing)Iron Armor$(0) in strength and durability.$(p)All pieces of a suit will draw from their wearer's excess $(thing)Psi energy$(0) to repair damage to themselves, a feat made possible by the $(l:components/psigem)$(item)Psigems$(0)$(/l) used in their construction.",
"psi.book.page.exosuit.6": "The $(item)Psimetal Exosuit Helmet$(0) is the most configurable of the bunch, casting its designated $(thing)Spell$(0) whenever its contained $(l:items/exosuit_sensor)$(thing)Exosuit Sensor$(0)$(/l) triggers.$(p)A $(l:items/exosuit_sensor)$(thing)Sensor$(0)$(/l) attaches to and detaches from a $(item)Helmet$(0) in a crafting grid; a $(item)Helmet$(0) can only have one $(l:items/exosuit_sensor)$(thing)Exosuit Sensor$(0)$(/l) attached at a time.",
"psi.book.page.exosuit.7": "You hear a sound, turn around",
"psi.book.page.exosuit.8": "The $(item)Psimetal Exosuit Chestplate$(0) casts its selected $(thing)Spell$(0) whenever its user takes any form of damage.$(p)$(piece)Selector: Attacker$(0) and $(piece)Selector: Damage Taken$(0) can be used to identify the source and amount of damage, respectively.",
"psi.book.page.exosuit.9": "Explosive Thorns",
"psi.book.page.exosuit.10": "$(item)Psimetal Exosuit Leggings$(0) $(o)never stop$() casting their selected $(thing)Spell$(0).$(p)In fact, they do so once per $(thing)CAD$(0) tick, which is a unit of time equal to 0.05 seconds.$(p)They're quite popular as "better $(l:items/loopcast_bullet)$(item)Loopcast Spell Bullets$(0)$(/l)."",
"psi.book.page.exosuit.11": "while(true) {}",
"psi.book.page.exosuit.12": "$(item)Psimetal Exosuit Boots$(0) simply cast their designated $(thing)Spell$(0) when their wearer jumps off the ground.$(p)No more, no less.",
"psi.book.page.exosuit.13": "Jump Boost-- er, Boots",
"psi.book.entry.exosuitSensor": "Exosuit Sensors",
"psi.book.page.exosuitSensor.0": "$(thing)Exosuit Sensors$(0) are small devices designed to be embedded into larger pieces of armor (e.g. the $(l:items/exosuit#helmet)$(item)Psimetal Exosuit Helmet$(0)$(/l)), and to signal their containing armor when triggered.$(p)Each $(thing)Sensor$(0) has a different condition for what triggers it.",
"psi.book.page.exosuitSensor.1": "All $(thing)Sensors$(0) are crafted from two $(item)Iron Ingots$(0) and two of $(l:components/psimetal)$(item)Psimetal$(0)$(/l) around a reagent; the reagent used determines the resulting $(thing)Sensor$(0)'s effect:$(p)$(li)the $(item)Light Sensor$(0) uses $(item)Glowstone Dust$(0);$(p)$(li)the $(item)Heat Sensor$(0) uses a $(item)Fire Charge$(0);$(p)$(li)the $(item)Stress Sensor$(0) uses a slice of $(item)Glistering Melon$(0);$(p)$(li)the $(item)Water Sensor$(0) uses $(item)Prismarine Crystals$(0);$(p)$(li)the $(item)Detonation Sensor$(0) uses $(item)Gunpowder$(0).",
"psi.book.page.exosuitSensor.2": "The $(item)Exosuit Light Sensor$(0) triggers once whenever its wearer moves into a dark area (i.e. an area that's dark enough to spawn monsters) from a non-dark area.$(p)It can be manually triggered in a dark area with a $(piece)Trick: Conjure Light$(0) on a timer.",
"psi.book.page.exosuitSensor.3": "Who turned out the lights?",
"psi.book.page.exosuitSensor.4": "The $(item)Exosuit Heat Sensor$(0) triggers whenever its wearer catches fire.$(p)$(piece)Trick: Fire Resistance$(0) or $(piece)Trick: Torrent$(0) are good responses to this $(thing)Sensor$(0) triggering, unless you $(o)really$() know what you're doing.",
"psi.book.page.exosuitSensor.5": "We carry on",
"psi.book.page.exosuitSensor.6": "The $(item)Exosuit Stress Sensor$(0) triggers when its wearer is low on health (specifically, if the wearer is at three hearts or less).$(p)$(piece)Trick: Regeneration$(0) might be a good response to this issue.",
"psi.book.page.exosuitSensor.7": "Don't panic",
"psi.book.page.exosuitSensor.8": "The $(item)Exosuit Water Sensor$(0) triggers when its wearer touches water.$(p)With a bit of ingenuity, it can be triggered manually via $(piece)Trick: Torrent$(0).",
"psi.book.page.exosuitSensor.9": "Make a splash",
"psi.book.page.exosuitSensor.10": "The $(item)Exosuit Detonation Sensor$(0) triggers whenever a $(l:items/detonator)$(item)Spell Detonator$(0)$(/l) is actuated within a 32-block radius, or when a $(piece)Trick: Detonate$(0) is cast in the same area.",
"psi.book.page.exosuitSensor.11": "At the push of a button",
"psi.book.entry.tools": "Psimetal Tools",
"psi.book.page.tools.0": "The $(thing)Psimetal Tools$(0) are a set of tools, comparable to $(item)Diamond$(0)-tier in quality, each of which can cast a $(thing)Spell$(0) each time it performs its intended action.$(p)All $(thing)Psimetal Tools$(0) are crafted with $(item)Iron Ingots$(0) in place of $(item)Sticks$(0), one $(l:components/psigem)$(item)Psigem$(0)$(/l), and some $(l:components/psimetal)$(item)Psimetal$(0)$(/l).",
"psi.book.page.tools.1": "It's a bonus action",
"psi.book.page.tools.2": "A $(thing)Psimetal Tool$(0) can be loaded with up to three $(l:items/spell_bullet)$(thing)Spell Bullets$(0)$(/l) in a $(l:basics/cad_assembler)$(item)CAD Assembler$(0)$(/l) (though some $(l:items/spell_bullet)$(thing)Spell Bullets$(0)$(/l) don't play well with the tools).$(p)To select the $(l:items/spell_bullet)$(thing)Spell Bullet$(0)$(/l) to use for a tool, hold the $(thing)Psi master keybind$(0) ($(k:psimisc.keybind)) and select from the menu as usual.$(p)Picking an empty slot from the menu disables the tool from casting entirely.",
"psi.book.page.tools.3": "All $(thing)Psimetal Tools$(0) except the $(item)Psimetal Sword$(0) cast their selected $(thing)Spell$(0) once each time they break a block.$(p)The $(item)Sword$(0) instead casts each time it hits a living being (though it should be noted for strategic purposes that once damaged, a living thing is invulnerable for half a second).$(p)$(thing)Psimetal Tools$(0) will draw from their wielder's excess $(thing)Psi energy$(0) to repair themselves.",
"psi.book.page.tools.4": "$(thing)Psimetal Tools$(0) also get some convenient integration with $(thing)Spell Pieces$(0).$(p)When the $(item)Psimetal Sword$(0) casts a $(thing)Spell$(0), $(piece)Selector: Attack Target$(0) returns the mob you whacked to do so.$(p)When one of the other $(thing)Tools$(0) breaks a block, $(piece)Selector: Block Broken$(0) returns the position of the broken block, and $(piece)Selector: Block Broken Side$(0) returns the axial vector corresponding to the direction the block was broken from.",
"psi.book.entry.vectorRuler": "Vector Ruler",
"psi.book.page.vectorRuler.0": "A $(item)Vector Ruler$(0) can store an arbitrary vector, which can then be accessed from within a $(thing)Spell$(0) at your convenience.$(p)It's made from $(item)Iron Ingots$(0) and a tip of $(l:components/psidust)$(item)Psidust$(0)$(/l).",
"psi.book.page.vectorRuler.1": "Vectors rule",
"psi.book.page.vectorRuler.2": "Tapping a $(item)Ruler$(0) on a block ($(k:use)) while crouching stores that block's position in the $(item)Ruler$(0) as a vector.$(p)Once a block's position is stored, tapping the $(item)Ruler$(0) without crouching on another block will store the offset between the two blocks.$(p)A $(item)Ruler$(0)'s stored vector can be accessed with $(piece)Selector: Vector Ruler$(0).",
"psi.book.page.vectorRuler.3": "If you happen to be carrying several $(item)Rulers$(0) at a time, $(piece)Selector: Vector Ruler$(0) will return the stored value of the leftmost $(item)Ruler$(0) in your hotbar, or the highest $(item)Ruler$(0) in your inventory if your hotbar has none.",
"psi.book.entry.spellDrive": "Spell Drive",
"psi.book.page.spellDrive.0": "A $(item)Spell Drive$(0), crafted from two ingots of $(l:components/psimetal)$(item)Psimetal$(0)$(/l) and a piece of $(item)Redstone Dust$(0), can store a single $(thing)Spell$(0) for later use.$(p)To store a $(thing)Spell$(0) in a $(l:basics/spell_programmer)$(item)Spell Programmer$(0)$(/l) onto a $(item)Drive$(0), crouch and swipe ($(k:use)) an empty $(item)Drive$(0) over it.$(p)To copy a $(thing)Spell$(0) back, crouch-swipe a $(item)Drive$(0) with a $(thing)Spell$(0) stored over the $(l:basics/spell_programmer)$(item)Programmer$(0)$(/l).",
"psi.book.page.spellDrive.1": "Build yourself a library",
"psi.book.page.spellDrive.2": "To clear a stored $(thing)Spell$(0), crouch-swipe the $(item)Drive$(0) over any other block.$(p)A $(item)Drive$(0) with a stored $(thing)Spell$(0) can be placed in a crafting grid with an empty $(item)Drive$(0) or $(l:items/spell_bullet)$(thing)Spell Bullet$(0)$(/l) to copy its $(thing)Spell$(0) onto the latter.",
"psi.book.category.legacy": "Legacy Entries",
"psi.book.category.legacy.desc": "These entries are a holdover from the days of $(thing)Psi$(0) for 1.12 and below. As this book fills up with rewritten documentation, this section will shrink in size until all documentation is ported, when it'll vanish for good.",
"psi.book.entry.vectors101": "Vectors 101",
"psi.book.page.vectors101.0": "The manipulation of vectors is an essential component to $(thing)Spell$(0) programming. Most vector operations are outlined $(l:basics/vector_primer#ops)here$(/l); the only missing piece is $(piece)Operator: Vector Cross Product$(0).",
"psi.book.page.vectors101.1": "The $(l)cross product$() of two vectors is a vector that is perpendicular to both. You can make use of this to get a vector that points to your side, by taking the cross product of the player's look vector and [0, 1, 0] (which you can create with $(piece)Operator: Vector Construct$(0)). ",
"psi.book.entry.entities101": "Entities 101",
"psi.book.page.entities101.0": "The manipulation of entities is an essential component to $(thing)Spell$(0) programming. The most obvious entity to manipulate is you, the caster, via $(piece)Selector: Caster$(0). Other pieces, however, allow you to target other entities in the world.$(p)You can make use of those pieces to create $(thing)Spells$(0) that affect other entities. Try using them with $(piece)Trick: Add Motion$(0) to fling around others.",
"psi.book.entry.blockworks": "Blockworks",
"psi.book.page.blockworks.0": "Working with blocks is an essential skill for a mage. You can, of course, refer to a block's position via a vector, so knowledge of vectors is important to understand how to work with blocks.$(p)Two of the most basic block pieces in this group are $(piece)Trick: Place Block$(0) and $(piece)Trick: Break Block$(0).",
"psi.book.page.blockworks.1": "These both take a position vector, and respectively place and break a block at that position. $(piece)Trick: Place Block$(0) uses the block to the right of your $(thing)CAD$(0) in your hotbar for placing. Knowing the block position to break is easy; $(piece)Operator: Vector Raycast$(0) suffices.",
"psi.book.page.blockworks.2": "However, placing a block is trickier: $(piece)Operator: Vector Raycast$(0) gives us the block the player is looking at. We can't place a block there-- there already $(o)is$() one! To remedy that, we can combine our $(piece)Operator: Vector Raycast$(0) with the $(piece)Operator: Vector Axis Raycast$(0) piece, which gives us a vector representing the side of the block we're looking at. ",
"psi.book.page.blockworks.3": "For example, if we're looking at the top of the block, it'll give us the axial vector [0, 1, 0]. We can use $(piece)Operator: Vector Sum$(0) to add it to our plain Raycast to tell us where our block will go!$(p)$(piece)Operator: Entity Axial Look$(0) is similar to $(piece)Operator: Entity Look$(0), but returns a value snapped to one of the six axial vectors (e.g. if you're looking east, it returns [1, 0, 0]). Think of the "Facing" value in your F3 menu.",
"psi.book.page.blockworks.4": "The other two $(thing)Tricks$(0) available here are $(piece)Trick: Place Block Sequence$(0) and $(piece)Trick: Break Block Sequence$(0). These $(thing)Tricks$(0) break or place a line of blocks. Similarly to the standard break and place $(thing)Tricks$(0), they require a position to start off, but they also require another Vector, "Target", that defines the direction to operate in. So if "Target" is [0, 1, 0], it'll place or break blocks starting from the value of "Position" upwards.",
"psi.book.page.blockworks.5": "The last component to these $(thing)Tricks$(0) is "Max", this is a number constant for the maximum amount of blocks the $(thing)Trick$(0) is allowed to break or place. Since the vector requirements aren't constant, this works as means of calculating the Potency and Cost of the $(thing)Trick$(0). The higher you set it, the more the $(thing)Spell$(0) will cost.$(p)The last piece in this group is $(piece)Operator: Vector Project$(0).",
"psi.book.page.blockworks.6": "Vector Projection is a somewhat complex topic, so we'll only explain a potential uses for it below.$(p)Say you want to make a $(thing)Spell$(0) that places blocks from your position in the world to the position you're looking at, but in a straight line aligned to the side of the block you're looking at (using $(piece)Operator: Vector Axis Raycast$(0)).",
"psi.book.page.blockworks.7": "You start off by finding the vector that you want to place blocks along, so you can plug it into $(piece)Trick: Place Block Sequence$(0). If you're diagonal to the block, though, you may get something like [3, 2, 4]. That's not a straight line! We can use $(piece)Operator: Vector Project$(0) to project that into the axis of the side you're looking at, say, [0, 0, 1].",
"psi.book.page.blockworks.8": "So our "Vector A" is [3, 2, 4] and our "Vector B" is [0, 0, 1]. Applying the projection leaves us with [0, 0, 4]. If our "Vector B", was, for example, [1, 0, 0], we'd get [3, 0, 0]. In general, when an axial vector is used for "Vector B", $(piece)Operator: Vector Project$(0) strips any components of A that are 0 in B, leaving you with a straight line.$(p)To put it all together, try making a $(thing)Spell$(0) that brings down an 8 block high column, so you can "treecapitate"!",
"psi.book.entry.movementAdvances": "Movement Advances",
"psi.book.page.movementAdvances.0": "The basics of movement $(thing)Tricks$(0) were covered when we talked about $(piece)Trick: Add Motion$(0). This group has pieces that improve on that idea.$(p)$(piece)Trick: Blink$(0) simply teleports the target entity forwards in the direction they're looking in. A negative value will teleport the entity backwards.",
"psi.book.page.movementAdvances.1": "$(piece)Trick: Mass Blink$(0) does the same as $(piece)Trick: Blink$(0), but accepts an Entity List instead; each entity in the list is individually affected by the $(thing)Trick$(0).$(p)$(piece)Trick: Mass Add Motion$(0) is similar; it's the Entity List version of $(piece)Trick: Add Motion$(0).$(p)Finally, $(piece)Trick: Mass Exodus$(0) pulls every entity in an Entity List towards a given position, at the given speed. A negative speed will push them away instead. ",
"psi.book.entry.blockMovement": "Block Movement",
"psi.book.page.blockMovement.0": "The ability to move blocks isn't as important as the ability to break and place them, but happens to be quite useful nonetheless.$(p)$(piece)Trick: Move Block$(0) takes a position for a block in the world and moves it in the target vector's direction, as if it were pushed by a piston. The target vector must be axial; if it isn't, the $(thing)Trick$(0) will fail.",
"psi.book.page.blockMovement.1": "On the other hand, $(piece)Trick: Collapse Block$(0) causes a block to fall as if it were sand or gravel.$(p)Both these $(thing)Tricks$(0) will fail to execute on complex blocks (those known as Tile Entities) and blocks that can't be harvested with Silk Touch. ",
"psi.book.entry.elementalArts": "Elemental Arts",
"psi.book.page.elementalArts.0": "What's a magic system without the ability to cast elemental $(thing)Spells$(0)?$(p)This group contains $(thing)Tricks$(0) for the four elements; for example, $(piece)Trick: Smite$(0) summons a lightning bolt at the position it's told to.",
"psi.book.page.elementalArts.1": "The group also contains $(piece)Operator: Random$(0), a piece that will generate a random number between 0 (inclusive) and the number passed in (exclusive). This can be used alongside Loopcast or Spell Circle $(thing)Spells$(0) in many ways. For example, one can create a $(thing)Spell$(0) that would use $(piece)Trick: Overgrow$(0) to mass bone meal a plantation. ",
"psi.book.entry.positiveEffects": "Positive Effects",
"psi.book.page.positiveEffects.0": "The ability to apply magical effects to things and people is a must-have feature of any magical lexicon worth its weight. We're not writing $(thing)Spells$(0) from a spellbook, but you can apply effects to entities anyway.$(p)All of the pieces in this group will apply their respective potion effect to the target entity, for the given time (in seconds).",
"psi.book.page.positiveEffects.1": "If the piece also has a Power parameter, it represents the level of the effect to apply.$(p)For example, $(piece)Trick: Speed$(0) with Time 20 and Power 2 would apply a Speed II effect for 20 seconds to the target entity. ",
"psi.book.entry.negativeEffects": "Negative Effects",
"psi.book.page.negativeEffects.0": "As one might expect, with $(l:legacy/positive_effects)Positive Effects$(/l) come Negative Effects.$(p)There isn't much to say here, really. All tricks in this group do exactly what they say on the tin.$(p)Have fun. ",
"psi.book.entry.trigonometry": "Trigonometry",
"psi.book.page.trigonometry.0": "This group includes $(thing)Operators$(0) relevant to trigonometric functions. $(piece)Constant: Pi$(0) is exactly what it says on the tin, a constant that gives you the value of \u03c0=3.1415\u2026.$(p)This group includes elementary trigonometric operations as well: the sine and cosine functions, as well as their inverses (arcsine and arccosine).",
"psi.book.page.trigonometry.1": "Additionally, $(piece)Operator: Vector Dot Product$(0) returns the dot product of two vectors: the product of the two vectors' magnitudes times the cosine of the angle between them. Using $(piece)Operator: Arc Cosine$(0) on the result will allow you to get the angle between two vectors. ",
"psi.book.entry.smeltery": "Smeltery",
"psi.book.page.smeltery.0": "The pieces in this group are function quite simply; they all smelt things into other things as if they had been put in a furnace.$(p)$(piece)Trick: Smelt Item$(0) will cook a single dropped item in the world into its smelted counterpart.",
"psi.book.page.smeltery.1": "$(piece)Trick: Smelt Block$(0) will smelt a block in the world into its smelted version, provided that that smelted form's also a block.$(p)So Cobblestone can be smelted into Stone, and then into Smooth Stone, but a log won't smelt into Charcoal. ",
"psi.book.entry.flowControl": "Flow Control",
"psi.book.page.flowControl.0": "Flow Control is a somewhat complex subject. All the pieces here included allow a $(thing)Spell$(0) to function in wildly different ways. However, understanding how to properly use these pieces requires knowledge of the very internals of the spellcasting system-- have a read through $(l:basics/eval_order)this article$(/l) for more information.",
"psi.book.page.flowControl.1": "With that info under your belt, let's start off with $(piece)Trick: Sleep$(0). This piece causes the $(thing)Spell$(0) from which it's cast to delay its execution for the number of ticks it receives. (A tick is a span of 0.05 seconds.) So if you wish to delay further processing of a $(thing)Spell$(0) by half a second, you would use 10 as the "Time" parameter. $(piece)Trick: Sleep$(0) does not add any $(l:basics/tutorial_5#projection)$(thing)Projection$(0)$(/l) to your $(thing)Spell$(0), but does cost $(l:basics/tutorial_5#potency)$(thing)Potency$(0)$(/l).",
"psi.book.page.flowControl.2": "$(piece)Trick: Evaluate$(0) is a $(thing)Trick$(0) that does absolutely nothing.$(p)Yes, you heard that right. This $(thing)Trick$(0) does nothing. It doesn't add to any stats on your $(thing)Spell$(0), either.$(p)Its only practical use is to evaluate a value before a $(piece)Trick: Sleep$(0) executes, allowing you to, for example, get the place an entity was before the $(piece)Trick: Sleep$(0) triggered, for use later in the $(thing)Spell$(0).",
"psi.book.page.flowControl.3": "$(piece)Trick: Die$(0), on the other hand, is a Flow Control piece in the proper sense of the term.$(p)It takes a Number parameter, and if that number's absolute value lies strictly below 1 (also exclusive), it fizzles the $(thing)Spell$(0) right then and there. Any other values passed to the $(thing)Trick$(0) will allow the $(thing)Spell$(0) to continue on as usual.$(p)This piece doesn't cost $(l:basics/tutorial_5#projection)$(thing)Projection$(0)$(/l).",
"psi.book.page.flowControl.4": "A very simple way to put $(piece)Trick: Die$(0) to use is to couple it to $(piece)Selector: Sneak Status$(0), which conveniently returns 0 if the caster is sneaking and 1 if they're not.$(p)Why, it's almost as if they were made to be used together!",
"psi.book.page.flowControl.5": "$(piece)Constant: Wrapper$(0) allows you to use pieces that return Numbers for $(thing)Tricks$(0) that would otherwise require Number Constants.$(p)As you should know by now, Number Constants fed to $(thing)Tricks$(0) are used to calculate a $(thing)Spell$(0)'s stats (including $(l:basics/tutorial_5#cost)$(thing)Cost$(0)$(/l)) before the $(thing)Spell$(0)it's ever cast.$(p)Since these Constants are required at compile-time, simple Numbers that get evaluated at execution-time are clearly unusable here.",
"psi.book.page.flowControl.6": "$(piece)Constant: Wrapper$(0) gets around this by accepting two Numbers, a Constant and a non-Constant.$(p)The Constant passed to the piece will be ** used for $(thing)Spell$(0) compilation calculations; but the non-Constant number will be ** used when the $(thing)Spell$(0) is actually executed.$(p)The non-Constant Number's value will be capped at the value of the Constant during $(thing)Spell$(0) execution, to prevent tomfoolery.",
"psi.book.page.flowControl.7": "The execution-time Number has its sign changed to the sign of the Number Constant, so that the signs of both numbers match. If the Constant Number is 0, $(piece)Constant: Wrapper$(0) always returns 0, regardless of input.",
"psi.book.entry.blockConjuration": "Block Conjuration",
"psi.book.page.blockConjuration.0": "This group includes pieces that do exactly as advertised: they conjure blocks.$(p)$(piece)Trick: Conjure Block$(0) creates a Conjured Block, a semi-transparent solid block, at the given position. Conjured Blocks, if conjured with a "Time" parameter, can quietly break themselves after the specified time has elapsed.",
"psi.book.page.blockConjuration.1": "If the "Time" parameter is used, it's specified in ticks (units of 0.05 seconds). Thus, if you want to make a block that disappears after half a second, set the "Time" parameter to 10 ticks.$(p)$(piece)Trick: Conjure Light$(0) conjures a light source instead, one that can't be collided against.",
"psi.book.page.blockConjuration.2": "$(piece)Trick: Conjure Block Sequence$(0) functions much like $(piece)Trick: Place Block Sequence$(0), but creates Conjured Blocks instead. Both these pieces also include a "Time" parameter.$(p)Conjured Blocks are fragile, and will break instantly to any tool a player cares to swing at them.",
"psi.book.entry.eidosManipulation": "Eidos Manpulation",
"psi.book.page.eidosManipulation.0": "Eidos $(thing)Tricks$(0) allow their caster to manipulate the space-time continuum in their favor.$(p)$(piece)Trick: Eidos Reversal$(0) causes its caster to retrace their steps in reverse, at double speed, for the amount of time (in seconds) specified.",
"psi.book.page.eidosManipulation.1": "Only one Eidos Reversal may be active at a time, and after a Reversal is cast, any subsequent Reversals can only reverse to the place where the last one ended. Sneaking will stop an ongoing Reversal.$(p)The other $(thing)Trick$(0) piece of the group, $(piece)Trick: Eidos Anchor$(0) creates an "anchor" for the caster.",
"psi.book.page.eidosManipulation.2": "After the specified amount of time (in seconds), the caster will be warped back to their anchor's location. Multiple executions of $(piece)Trick: Eidos Anchor$(0) can happen in quick succession, but only the last created anchor will activate.",
"psi.book.page.eidosManipulation.3": "Finally, $(piece)Selector: Eidos Changelog$(0) takes a single number parameter (let's call it n), and gives you the position in the n'th index of the Eidos Changelog starting from the end. In other words, it gives you a position vector to where you were n ticks ago.$(p)$(piece)Trick: Eidos Reversal$(0) takes you backwards in the changelog, wiping out any locations that occur "afterward." $(piece)Trick: Eidos Anchor$(0) does not modify the changelog. ",
"psi.book.entry.detectionDynamics": "Detection & Focus",
"psi.book.page.detectionDynamics.0": "This group includes two types of pieces, as the title says: detection, and focus. To understand this, the concept of Slot Focus must be introduced.",
"psi.book.page.detectionDynamics.1": "An already known example of Slot Focus is the family of Place Block style $(thing)Tricks$(0). These make use of the block directly to the right of your $(thing)CAD$(0). Slot Focus is the slot which $(thing)Tricks$(0) like these will use. It can be relative (to the position of your $(thing)CAD$(0)) or absolute, can only be in the hotbar and goes from 1 to 9.",
"psi.book.page.detectionDynamics.2": "By default, whenever a $(thing)Spell$(0) is cast, its value is "Relative 1", so it's 1 slot to the right of your $(thing)CAD$(0). If it was "Relative -1" it would be 1 slot to the left of your $(thing)CAD$(0). "Absolute 3" would be the third slot in your hotbar. It also loops around, so if you have your $(thing)CAD$(0) on your last slot and the value is "Relative 1", it'll be your first slot.",
"psi.book.page.detectionDynamics.3": "To set the focused slot, you can use $(piece)Trick: Switch Focus Slot$(0). This takes one of 2 parameters. Both are optional and mutually exclusive, and if you don't define any, it'll set the focus to the default of "Relative 1". If you choose to set the "Position" parameter, it'll set an Absolute value, whereas the "Shift" parameter will set a Relative value.",
"psi.book.page.detectionDynamics.4": "This allows you to, for example, build things with different blocks based on the circumstance. This $(thing)Trick$(0) only works for the current $(thing)Spell$(0) cast, and the focus will reset the next time a $(thing)Spell$(0) is cast (even if it's the same $(thing)Spell$(0)).$(p)The other two pieces in the group are set in the "detection" area.",
"psi.book.page.detectionDynamics.5": "First, $(piece)Selector: Item Presence$(0) takes an optional slot number (if not set it'll default to your Focused Slot), and returns the amount of items in that slot, 0 if it's empty, of course.",
"psi.book.page.detectionDynamics.6": "Lastly, $(piece)Selector: Block Presence$(0) takes a vector, to be used as coordinates in the world, and finds the block there, the value returned is 0 if there's no block or a replaceable block (like tall grass), 1 if it's a non-solid block and 2 if it's a solid block. ",
"psi.book.entry.memoryManagement": "Memory Management",
"psi.book.page.memoryManagement.0": "This group introduces the ability for a $(thing)Spell$(0) to store information persistently inside a $(thing)CAD$(0). A $(thing)CAD$(0) can save vectors to be retrieved in future $(thing)Spell$(0) executions. A $(thing)CAD$(0) can store one vector for every three $(l:components/socket)$(thing)Socket$(0)$(/l) slots it has.",
"psi.book.page.memoryManagement.1": "The number of vectors a $(thing)CAD$(0) can store is known as the number of $(thing)Memory Slots$(0) it has.$(p)This piece group includes two $(thing)Spell Pieces$(0), which can save and load vectors to and from a $(thing)CAD$(0)'s $(thing)Memory Slots$(0).$(p)$(piece)Trick: Save Vector$(0) saves a vector to a designated $(thing)Memory Slot$(0), whereas $(piece)Selector: Saved Vector$(0) retrieves the vector saved in the designated $(thing)Memory Slot$(0).",
"psi.book.page.memoryManagement.2": "A $(thing)CAD$(0)'s $(thing)Memory Slots$(0) are numbered starting from 1, so a $(thing)CAD$(0) with 3 memory slots can save to slots 1, 2, and 3.$(p)Both $(thing)Tricks$(0) in this group add $(l:basics/tutorial_5#potency)$(thing)Potency$(0)$(/l) to $(thing)Spells$(0) they're used in equal to the number of the slot used.$(p)For example, saving to or loading from slot 2 costs two $(l:basics/tutorial_5#potency)$(thing)Potency$(0)$(/l).",
"psi.book.page.memoryManagement.3": "$(piece)Trick: Save Vector$(0) has an imperfection: it "locks" the $(thing)Memory Slot$(0) it saves to.$(p)This prevents either of the two pieces from interacting with that same $(thing)Memory Slot$(0) later in the $(thing)Spell$(0).$(p)So if you need to load the value saved in a slot before you save something new to it, remember the rules of Flow Control to ensure the load happens before the save.",
"psi.book.entry.secondaryOperators": "Secondary Operators",
"psi.book.page.secondaryOperators.0": "As its name implies, this group is composed of mathematical $(thing)Operators$(0) that aren't quite as important as the "primary" ones, like addition or subtraction. This group's just a mixed bag of all sorts of math or logic relates pieces that can be used to help with $(thing)Spell$(0) creation. We'll separate the pieces in two sets to make them easier to explain.",
"psi.book.page.secondaryOperators.1": "The first set is related to raising numbers to power, including pieces like $(piece)Operator: Square$(0), $(piece)Operator: Power$(0), $(piece)Operator: Square Root$(0) and even $(piece)Operator: Logarithm$(0). Most of these operate exactly how you'd expect them to.$(p)Note that $(piece)Operator: Logarithm$(0) takes an optional Base argument; if no base is passed in, it'll default to base 10.$(p)$(piece)Constant: e$(0) can also be used to get a natural logarithm.",
"psi.book.page.secondaryOperators.2": "The second set of $(thing)Operators$(0) are related to logic. They're pieces that do rounding (to an integer).$(p)$(piece)Operator: Ceiling$(0), $(piece)Operator: Floor$(0) and $(piece)Operator: Round$(0) round up, down, and to the closest integer, respectively.$(p)This group also includes $(piece)Operator: Min$(0) and $(piece)Operator: Max$(0). These get the smallest and largest, respectively, of their parameters."
}

复制代码

部分汉化过的内容

大量有待翻译的内容

无谓z

https://cowtransfer.com/s/507b3bf48a1d47

下一页最后一页