机械动力机器数值分析 - 版本历史

Mr xian：/* 人话 */

2023-01-29T07:52:54Z

人话

←上一版本		2023年1月29日 (日) 07:52的版本
第275行：		第275行：

	==== 人话 ====		==== 人话 ====
			搅拌机最好连续工作，避免暖机问题

	下表为最佳转速，自行选取		下表为最佳转速，自行选取
	{\| class="wikitable"		{\| class="wikitable"

Mr xian：/* 分析 */

2023-01-28T16:28:31Z

分析

显示更改

Mr xian：/* 人话 */

2023-01-28T16:23:21Z

人话

←上一版本		2023年1月28日 (六) 16:23的版本
第94行：		第94行：
	\|1		\|1
	\|1		\|1
			\|240
	\|120		\|120
	~~\|120~~		\|0.083333333
	\|0.~~166666667~~
	\|-		\|-
	\|9		\|9
	\|2		\|2
	\|60		\|120
	\| ~~-60~~		\|0
	\|0.~~333333333~~		\|0.166666667
	\|-		\|-
	\|18		\|18
	\|3		\|3
	\|40		\|80
	\| -20		\|20
	\|0.5		\|0.25
	\|-		\|-
	\|27		\|27
	\|4		\|4
	\|30		\|60
	\| ~~-10~~		\|20
	\|0.~~666666667~~		\|0.333333333
	\|-		\|-
	\|35		\|35
	\|5		\|5
	\|24		\|48
	\| -6		\|18
	\|0.~~833333333~~		\|0.416666667
	\|-		\|-
	\|44		\|44
	\|6		\|6
	\|20		\|40
	\| -4		\|16
	\|1		\|0.5
	\|-		\|-
	\|53		\|53
	\|7		\|7
	\|18		\|36
	\| -2		\|16
	\|1.~~111111111~~		\|0.555555556
	\|-		\|-
	\|61		\|61
	\|8		\|8
	\|15		\|30
	\| -3		\|12
	\|1.~~333333333~~		\|0.666666667
	\|-		\|-
	\|70		\|70
	\|9		\|9
	\|14		\|28
	\| -1		\|13
	\|1.~~428571429~~		\|0.714285714
	\|-		\|-
	\|79		\|79
	\|10		\|10
	\|12		\|24
	\| -2		\|10
	\|1.~~666666667~~		\|0.833333333
	\|-		\|-
	\|87		\|87
	\|11		\|11
	\|11		\|22
	\| -1		\|10
	\|1.~~818181818~~		\|0.909090909
	\|-		\|-
	\|96		\|96
	\|12		\|12
	\|10		\|20
	\| -1		\|9
	\|2		\|1
	\|-		\|-
	\|113		\|113
	\|14		\|14
	\|9		\|18
	\| -1		\|8
	\|2.~~222222222~~		\|1.111111111
	\|-		\|-
	\|122		\|122
	\|15		\|15
	\|8		\|16
	\| -1		\|7
	\|2.5		\|1.25
	\|-		\|-
	\|148		\|148
	\|18		\|18
	\|7		\|14
	\| -1		\|6
	\|2.~~857142857~~		\|1.428571429
	\|-		\|-
	\|165		\|165
	\|20		\|20
	\|6		\|12
	\| -1		\|5
	\|3.~~333333333~~		\|1.666666667
	\|-		\|-
	\|200		\|200
	\|24		\|24
	\|5		\|10
	~~\| -1~~
	\|4		\|4
			\|2
	\|-		\|-
	\|252		\|252
	\|30		\|30
	\|4		\|8
	\| -1		\|3
	\|5		\|2.5
	\|}		\|}

Mr xian：/* 人话 */

2023-01-28T16:16:05Z

人话

显示更改

Mr xian：/* 人话 */

2023-01-28T15:59:36Z

人话

←上一版本		2023年1月28日 (六) 15:59的版本
第246行：		第246行：

	吹炼的物品堆满64一组，这样最快		吹炼的物品堆满64一组，这样最快

			=== 5 搅拌器 ===

			==== 分析 ====
			if (runningTicks != 20)

			runningTicks++;

			if ((!level.isClientSide \|\| isVirtual()) && runningTicks == 20) {

			上面说明搅拌机从睡觉转换到工作需要预热一秒

			.

			float recipeSpeed = 1;

			int t = ((ProcessingRecipe<?>) currentRecipe).getProcessingDuration();

			recipeSpeed = t / 100f;

			processingTicks = Mth.clamp((Mth.log2((int) (512 / speed))) * Mth.ceil(recipeSpeed * 15) + 1, 1, 512);

			processingTicks--;

			上面是搅拌机工作代码，每个从头开始处理的配方配方需要log2(int(512/转速))*15 tick 的时间

			由于这里有个int，因此搅拌机也是阶跃的，这时就可以用excel传统异能处理了

			==== 人话 ====
			下表为最佳转速，自行选取
			{\| class="wikitable"
			\|转速
			\|产量(每秒)
			\|筛选
			\|-
			\|32
			\|0.333333333
			\|#VALUE!
			\|-
			\|33
			\|0.341277366
			\|0.007944033
			\|-
			\|35
			\|0.35019938
			\|0.008922014
			\|-
			\|37
			\|0.360317539
			\|0.010118159
			\|-
			\|40
			\|0.371923928
			\|0.011606388
			\|-
			\|43
			\|0.385419768
			\|0.013495841
			\|-
			\|47
			\|0.401373328
			\|0.015953559
			\|-
			\|52
			\|0.420619836
			\|0.019246508
			\|-
			\|57
			\|0.444444444
			\|0.023824609
			\|-
			\|65
			\|0.474942916
			\|0.030498472
			\|-
			\|74
			\|0.515803743
			\|0.040860827
			\|-
			\|86
			\|0.574235411
			\|0.058431668
			\|-
			\|103
			\|0.666666667
			\|0.092431256
			\|-
			\|129
			\|0.841239671
			\|0.174573005
			\|-
			\|171
			\|1.333333333
			\|0.492093662
			\|}

Mr xian：/* 人话 */

2023-01-28T15:29:42Z

人话

←上一版本		2023年1月28日 (六) 15:29的版本
第47行：		第47行：
	另v分别等于0.25与20，我们可以得出，上方公式的适用范围		另v分别等于0.25与20，我们可以得出，上方公式的适用范围
	[[文件:01FF.png\|无\|缩略图]]		[[文件:01FF.png\|无\|缩略图]]
	~~高于红线则转速无效，低于蓝线则有增益~~		高于红线则降速到红线，低于蓝线则加速到蓝线

	==== 人话 ====		==== 人话 ====

Mr xian：/* 4 鼓风机 */

2023-01-28T15:27:06Z

4 鼓风机

←上一版本		2023年1月28日 (六) 15:27的版本
第239行：		第239行：

	将处理时间乘处理数量即为处理效率，使用excel轻松得		将处理时间乘处理数量即为处理效率，使用excel轻松得
			[[文件:02F.png\|无\|缩略图]]
			可见单堆物品数量越多，处理越快，最快速度为每秒1.73个物品

	==== 人话 ====		==== 人话 ====
			鼓风机速度只影响吹风距离，一速够了

			吹炼的物品堆满64一组，这样最快

120.231.138.216：/* 辊压机 */

2023-01-28T15:24:14Z

辊压机

←上一版本		2023年1月28日 (六) 15:24的版本
第3行：		第3行：
	== 开始 ==		== 开始 ==

	=== 基础 ===		=== 1 基础 ===
	1秒是20gametick（20t）		1秒是20gametick（20t）

	=== 粉碎轮 ===		=== 2 粉碎轮 ===

	==== 分析 ====		==== 分析 ====
第58行：		第58行：
	单位时间产量与转速成正比，1速64堆叠下粉碎轮每秒可处理3.2个物品		单位时间产量与转速成正比，1速64堆叠下粉碎轮每秒可处理3.2个物品

	=== 辊压机 ===		=== 3 辊压机 ===

	==== 分析 ====		==== 分析 ====
第200行：		第200行：
	\|5		\|5
	\|}		\|}

			=== 4 鼓风机 ===

			==== 分析 ====
			public final ConfigInt fanPushDistance = i(20, 5, "fanPushDistance", Comments.fanPushDistance);

			public final ConfigInt fanRotationArgmax = i(256, 64, "fanRotationArgmax", Comments.rpm, Comments.fanRotationArgmax);

			float distanceFactor = Math.min(speed / config.fanRotationArgmax.get(), 1);

			float pushDistance = Mth.lerp(distanceFactor, 3, config.fanPushDistance.get());

			这上面4是控制距离的，阅读易得距离k=speed/256*17+3

			.

			float sneakModifier = entity.isShiftKeyDown() ? 4096f : 512f;

			float speed = Math.abs(source.getSpeed());

			float acceleration = (float) (speed / sneakModifier / (entityDistance / maxDistance));

			这3控制吹生物速度，没啥用

			.

			public final ConfigInt inWorldProcessingTime = i(150, 0, "inWorldProcessingTime", Comments.inWorldProcessingTime);

			int timeModifierForStackSize = ((entity.getItem().getCount() - 1) / 16) + 1;

			int processingTime = (int) (AllConfigs.SERVER.kinetics.inWorldProcessingTime.get() * timeModifierForStackSize) + 1;

			int value = processing.getInt("Time") - 1;

			processing.putInt("Time", value);

			这堆是控制处理时间的，一叠物品的总处理时间是... (（数量-1）/16+1)*150... tick

			将处理时间乘处理数量即为处理效率，使用excel轻松得

			==== 人话 ====

120.231.138.216：/* 人话 */

2023-01-28T14:28:10Z

人话

←上一版本		2023年1月28日 (六) 14:28的版本
第1行：		第1行：
	冬季救援整合包里面的应力相对来说获取困难。为了极致地利用应力以及做好机器匹配，我查阅了相关代码并对其进行了分析。由于本人代码水平也不是很好，也没有编写java的经验，难免有解读错误的地方，望大佬继续补充。		冬季救援整合包里面的应力相对来说获取困难。为了极致地利用应力以及做好机器匹配，我查阅了相关代码并对其进行了分析。由于本人代码水平也不是很好，也没有编写java的经验，难免有解读错误的地方，望大佬继续补充。

			== 开始 ==

			=== 基础 ===
			1秒是20gametick（20t）

	=== 粉碎轮 ===		=== 粉碎轮 ===
第57行：		第62行：
	==== 分析 ====		==== 分析 ====
	public static final int CYCLE = 240;		public static final int CYCLE = 240;

			prevRunningTicks = runningTicks;

	runningTicks += (int) Mth.lerp(Mth.clamp(Math.abs(speed) / 512f, 0, 1), 1, 60);		runningTicks += (int) Mth.lerp(Mth.clamp(Math.abs(speed) / 512f, 0, 1), 1, 60);

	runningTicks > CYCLE		if (prevRunningTicks < CYCLE / 2 && runningTicks >= CYCLE / 2)

			runningTicks = CYCLE / 2;

			if(runningTicks > CYCLE)

			完成（）

	这里的speed就直接是转速了		这里的speed就直接是转速了
第66行：		第79行：
	lerp函数作用是将0-1小数等比放大到一定范围内		lerp函数作用是将0-1小数等比放大到一定范围内

	~~但是这都不重要，重要的是这玩意是基本线性的，容易列出单个物品处理时间近似为t=240/(60*speed/512)/20=102.4/speed (S)~~		由于cycle很小，mc又按t计算，因此处理速度是阶跃的

	~~每秒可产物品数量speed/102.4~~		观察易得其为两个120的阶跃进度，因此处理速度需要为120的因数才最好，用excel可轻松求出阶跃转速

	==== 人话 ====		==== 人话 ====
	~~辊压机转速除102~~.~~4就是每秒可产的物品数量~~		下表转速为最佳转速，自行选取即可
			{\| class="wikitable"
			\|转速
			\|增速
			\|需时(tick)
			\|筛选
			\|产量(每秒)
			\|-
			\|1
			\|1
			\|120
			\|120
			\|0.166666667
			\|-
			\|9
			\|2
			\|60
			\| -60
			\|0.333333333
			\|-
			\|18
			\|3
			\|40
			\| -20
			\|0.5
			\|-
			\|27
			\|4
			\|30
			\| -10
			\|0.666666667
			\|-
			\|35
			\|5
			\|24
			\| -6
			\|0.833333333
			\|-
			\|44
			\|6
			\|20
			\| -4
			\|1
			\|-
			\|53
			\|7
			\|18
			\| -2
			\|1.111111111
			\|-
			\|61
			\|8
			\|15
			\| -3
			\|1.333333333
			\|-
			\|70
			\|9
			\|14
			\| -1
			\|1.428571429
			\|-
			\|79
			\|10
			\|12
			\| -2
			\|1.666666667
			\|-
			\|87
			\|11
			\|11
			\| -1
			\|1.818181818
			\|-
			\|96
			\|12
			\|10
			\| -1
			\|2
			\|-
			\|113
			\|14
			\|9
			\| -1
			\|2.222222222
			\|-
			\|122
			\|15
			\|8
			\| -1
			\|2.5
			\|-
			\|148
			\|18
			\|7
			\| -1
			\|2.857142857
			\|-
			\|165
			\|20
			\|6
			\| -1
			\|3.333333333
			\|-
			\|200
			\|24
			\|5
			\| -1
			\|4
			\|-
			\|252
			\|30
			\|4
			\| -1
			\|5
			\|}

Mr xian：/* 粉碎轮 */

2023-01-28T13:31:55Z

粉碎轮

←上一版本		2023年1月28日 (六) 13:31的版本
第52行：		第52行：

	单位时间产量与转速成正比，1速64堆叠下粉碎轮每秒可处理3.2个物品		单位时间产量与转速成正比，1速64堆叠下粉碎轮每秒可处理3.2个物品

			=== 辊压机 ===

			==== 分析 ====
			public static final int CYCLE = 240;

			runningTicks += (int) Mth.lerp(Mth.clamp(Math.abs(speed) / 512f, 0, 1), 1, 60);

			runningTicks > CYCLE

			这里的speed就直接是转速了

			lerp函数作用是将0-1小数等比放大到一定范围内

			但是这都不重要，重要的是这玩意是基本线性的，容易列出单个物品处理时间近似为t=240/(60*speed/512)/20=102.4/speed (S)

			每秒可产物品数量speed/102.4

			==== 人话 ====
			辊压机转速除102.4就是每秒可产的物品数量