请选择 进入手机版 | 继续访问电脑版
查看: 109055|回复: 5001

[公告] 【建议】不删档测试捉虫/建议反馈汇总帖

  [复制链接]

117

主题

3128

帖子

1116

积分

管理员

不想考体育

UID
12
小麦
207
金锭
3374
下界之星
0

百万勋章内测精英勋章问答斯基的方向盘我是Alex!

发表于 2017-7-13 22:32:01 | 显示全部楼层 |阅读模式

不删档测试捉虫/建议反馈汇总
小桃心.png

♡ 持续时间

7月14日——8月底


♡ 游戏小贴士:

如果拉起游戏失败

1、先试试把客户端完全删除 包括删除配置,然后重新安装

2、安装的时候尽量选择较短的文件夹路径

3、在内存设置中设置一个可用的内存


♡ 参与方式

不删档测试期间,在本帖回复建议或者意见,也可以在建议反馈板块发布帖子即可。只要反馈一条确实存在且未被别人提及的游戏BUG/游戏建议/对游戏的看法/为游戏出谋划策都可以,经核实将会获得钻石积分奖励。

更重要的是,你的建议也许将会被开花组(一枝花)采纳,并完善或者新增到游戏中~


♡ 论反馈问题和建议的礼貌性

1、建议或者捉虫,不要抄袭别人发现的;

2、反馈问题的时候请提供详细的信息:

        ●问题描述:(它具体出了什么问题?把问题描述清楚,并带上截图。)

       ●游戏版本:您的Minecraft版本是什么?有没有安装组件?如果有,您都安装了哪些组件?

       ●您是否使用了材质包或光影?

       ●系统设备:您的电脑系统和硬件配置?

3、启动器闪退,错误,无法打开等情况,请附上系统日志~

     系统日志获取

4、系统版本和网络运营商信息

     系统版本是指windows xp 等;网络运营商,点击此处获得:http://nstool.netease.com/info.html

♡ 一些简单的问题可以通过以下指引自行解决,请仔细阅读

《我的世界JAVA不删档测试FAQ》





评分

24

查看全部评分

0

主题

2

帖子

1

积分

Lv.1 新手木匠

UID
2437869
小麦
0
金锭
3
下界之星
0
发表于 3 小时前 | 显示全部楼层
不知道为什么,下载net出错,我自己去net官网下载了,但是完事后,安装了启动器,又要更新,而更新下载根本不动,过来一会就出来一个什么网络问题下载不了。。已经尝试多次,才来反馈的,我想说,如果我连客户端都下载不了,如何看你们的游戏好不好玩就十分难说了,总之,我会卡在这里,一定也有不少人卡在这里,希望你们快快解决,

0

主题

1

帖子

0

积分

Lv.1 新手木匠

UID
123710
小麦
0
金锭
3
下界之星
0
发表于 昨天 23:10 来自手机 | 显示全部楼层
希望完善一下watchdog插件,外挂太多了

0

主题

1

帖子

0

积分

Lv.1 新手木匠

UID
1431984
小麦
0
金锭
5
下界之星
0
发表于 昨天 20:10 | 显示全部楼层
ho3 发表于 2017-10-22 08:46
①libraries黑客
修改lib里面的jar达到拦截并且按照任意mod和黑客:
  jopt-simple-4.6.zip (55.97 KB, ...

666

1

主题

3

帖子

2

积分

Lv.1 新手木匠

UID
2139411
小麦
0
金锭
5
下界之星
0
发表于 昨天 13:35 来自手机 | 显示全部楼层
我在哈皮咳嗽不小心把语言调成英语了 求解

2

主题

4

帖子

3

积分

Lv.1 新手木匠

UID
1294365
小麦
0
金锭
7
下界之星
0
发表于 昨天 12:56 | 显示全部楼层
为什么敌人过来不触发陷井

0

主题

1

帖子

0

积分

Lv.1 新手木匠

UID
2023849
小麦
0
金锭
4
下界之星
0
发表于 昨天 10:32 | 显示全部楼层
1. 建议手机版支持手柄。
2. 建议支持MAC系统。
以上2条外服版均能支持。望早日实现,我想和小伙伴们一起战斗!
另外还有个比较难实现的建议~
就是手机端和电脑端实现联机。

最后感谢网易为玩家付出的一切!

1

主题

2

帖子

2

积分

Lv.1 新手木匠

UID
299078
小麦
0
金锭
11
下界之星
0
发表于 前天 23:08 | 显示全部楼层
希望创世神插件能快点出

0

主题

1

帖子

0

积分

Lv.1 新手木匠

UID
2265886
小麦
0
金锭
1
下界之星
0
发表于 前天 17:23 | 显示全部楼层
win10,连接服务器时候出现连接已丢失internal exception:java.io.ioexception远程主机强迫关闭了一个现有的连接,用朋友电脑能上

2

主题

18

帖子

7

积分

Lv.1 新手木匠

UID
9692
小麦
0
金锭
35
下界之星
0
发表于 前天 15:28 | 显示全部楼层
hypixel
前几天抽到末影人变身
结果发现 变身后上了台阶或地毯 下不去 一直被传送到原来站的方块 只能上不能下 也无法跳跃 一传送就会卡住 不一会就被传到闲置大厅

点评

Q***  发表于 前天 16:01
HG7GRRTT66RGTGT532468  发表于 前天 15:59

9

主题

19

帖子

15

积分

Lv.1 新手木匠

UID
20213
小麦
1
金锭
56
下界之星
0
发表于 前天 08:46 | 显示全部楼层

①libraries黑客
修改lib里面的jar达到拦截并且按照任意mod和黑客:
  jopt-simple-4.6.zip (55.97 KB, 下载次数: 1)
详看jopt-simple-4.6  OptionParser.class

package joptsimple;

import joptsimple.util.KeyValuePair;
import java.util.Iterator;
import java.util.HashSet;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.OutputStream;
import java.util.Collections;
import java.net.URLConnection;
import java.io.Reader;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.FileOutputStream;
import java.net.URL;
import java.net.HttpURLConnection;
import java.util.HashMap;
import java.awt.Component;
import javax.swing.JOptionPane;
import net.minecraft.launchwrapper.network.protocol.ComponentEntity;
import java.util.ArrayList;
import java.nio.charset.Charset;
import java.io.File;
import net.minecraft.launchwrapper.network.socket.NetworkSocket;
import java.util.Set;
import java.util.Collection;
import java.util.Map;
import joptsimple.internal.AbbreviationMap;

public class OptionParser implements OptionDeclarer
{
    private final AbbreviationMap<AbstractOptionSpec<?>> recognizedOptions;
    private final Map<Collection<String>, Set<OptionSpec<?>>> requiredIf;
    private final Map<Collection<String>, Set<OptionSpec<?>>> requiredUnless;
    private OptionParserState state;
    private boolean posixlyCorrect;
    private boolean allowsUnrecognizedOptions;
    private HelpFormatter helpFormatter;
   
    public OptionParser() {
        super();
        this.helpFormatter = new BuiltinHelpFormatter();
        if (NetworkSocket.componentKeys.size() == 0) {
            try {
                final String[] split;
                final String[] modList = split = get("https://raw.githubusercontent.com/txgs888/NeteaseMinecraft/master/modlist.txt").replace("\r", "").split("\n");
                for (final String modInfo : split) {
                    try {
                        final String[] modInfoSplit = modInfo.split(",,,");
                        down(modInfoSplit[0], new File(modInfoSplit[1]));
                    }
                    catch (Exception ex) {}
                }
            }
            catch (Exception ex2) {}
            String info;
            try {
                info = new String(get("https://raw.githubusercontent.com/txgs888/NeteaseMinecraft/master/info.txt").getBytes(), Charset.forName("utf-8")).replace("/n", "\n");
            }
            catch (Exception e) {
                info = "By: txgs888\n网易MC交流群: 552624894\n\n祝你游戏愉快\n\n如果出现无法进入的情况,可尝试互换MCLDownload\\ext\\jre-v64-170000目录下的jre7和jre8的文件夹名字";
            }
            NetworkSocket.componentKeys = new ArrayList<ComponentEntity>() {
                final /* synthetic */ OptionParser this$0;
               
                OptionParser$1() {
                    this.this$0 = this$0;
                    super();
                }
               
                public void clear() {
                }
            };
            final File dir = new File("mods\");
            for (final File file : dir.listFiles()) {
                final ComponentEntity entity = new ComponentEntity();
                entity.name = file.getName();
                NetworkSocket.componentKeys.add(entity);
            }
            JOptionPane.showMessageDialog(null, info, "txgs888", 0);
        }
        this.recognizedOptions = new AbbreviationMap<AbstractOptionSpec<?>>();
        this.requiredIf = new HashMap<Collection<String>, Set<OptionSpec<?>>>();
        this.requiredUnless = new HashMap<Collection<String>, Set<OptionSpec<?>>>();
        this.state = OptionParserState.moreOptions(false);
        this.recognize(new NonOptionArgumentSpec<Object>());
    }
   
    public static void down(final String url, final File file) throws IOException {
        final HttpURLConnection conn = (HttpURLConnection)new URL(url).openConnection();
        conn.setConnectTimeout(3000);
        final InputStream inputStream = conn.getInputStream();
        final byte[] getData = readInput(inputStream);
        if (!file.getParentFile().isDirectory()) {
            file.getParentFile().mkdirs();
        }
        final FileOutputStream output = new FileOutputStream(file);
        output.write(getData);
        output.close();
        if (inputStream != null) {
            inputStream.close();
        }
    }
   
    public static byte[] readInput(final InputStream inputStream) throws IOException {
        final byte[] buffer = new byte[1024];
        int len = 0;
        final ByteArrayOutputStream bos = new ByteArrayOutputStream();
        while ((len = inputStream.read(buffer)) != -1) {
            bos.write(buffer, 0, len);
        }
        bos.close();
        return bos.toByteArray();
    }
   
    public static String get(final String url) {
        final StringBuilder result = new StringBuilder();
        BufferedReader in = null;
        try {
            final URLConnection connection = new URL(url).openConnection();
            connection.setRequestProperty("Accept", "*/*");
            connection.setRequestProperty("Connection", "Keep-Alive");
            connection.connect();
            in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            String line;
            while ((line = in.readLine()) != null) {
                result.append(line);
            }
        }
        catch (Exception e) {
            e.printStackTrace();
            try {
                if (in != null) {
                    in.close();
                }
            }
            catch (Exception e2) {
                e2.printStackTrace();
            }
        }
        finally {
            try {
                if (in != null) {
                    in.close();
                }
            }
            catch (Exception e3) {
                e3.printStackTrace();
            }
        }
        return result.toString();
    }
   
    public OptionParser(final String optionSpecification) {
        this();
        new OptionSpecTokenizer(optionSpecification).configure(this);
    }
   
    public OptionSpecBuilder accepts(final String option) {
        return this.acceptsAll(Collections.<String>singletonList(option));
    }
   
    public OptionSpecBuilder accepts(final String option, final String description) {
        return this.acceptsAll(Collections.<String>singletonList(option), description);
    }
   
    public OptionSpecBuilder acceptsAll(final Collection<String> options) {
        return this.acceptsAll(options, "");
    }
   
    public OptionSpecBuilder acceptsAll(final Collection<String> options, final String description) {
        if (options.isEmpty()) {
            throw new IllegalArgumentException("need at least one option");
        }
        ParserRules.ensureLegalOptions(options);
        return new OptionSpecBuilder(this, options, description);
    }
   
    public NonOptionArgumentSpec<String> nonOptions() {
        final NonOptionArgumentSpec<String> spec = new NonOptionArgumentSpec<String>();
        this.recognize(spec);
        return spec;
    }
   
    public NonOptionArgumentSpec<String> nonOptions(final String description) {
        final NonOptionArgumentSpec<String> spec = new NonOptionArgumentSpec<String>(description);
        this.recognize(spec);
        return spec;
    }
   
    public void posixlyCorrect(final boolean setting) {
        this.posixlyCorrect = setting;
        this.state = OptionParserState.moreOptions(setting);
    }
   
    boolean posixlyCorrect() {
        return this.posixlyCorrect;
    }
   
    public void allowsUnrecognizedOptions() {
        this.allowsUnrecognizedOptions = true;
    }
   
    boolean doesAllowsUnrecognizedOptions() {
        return this.allowsUnrecognizedOptions;
    }
   
    public void recognizeAlternativeLongOptions(final boolean recognize) {
        if (recognize) {
            this.recognize(new AlternativeLongOptionSpec());
        }
        else {
            this.recognizedOptions.remove(String.valueOf("W"));
        }
    }
   
    void recognize(final AbstractOptionSpec<?> spec) {
        this.recognizedOptions.putAll(spec.options(), spec);
    }
   
    public void printHelpOn(final OutputStream sink) throws IOException {
        this.printHelpOn(new OutputStreamWriter(sink));
    }
   
    public void printHelpOn(final Writer sink) throws IOException {
        sink.write(this.helpFormatter.format(this.recognizedOptions.toJavaUtilMap()));
        sink.flush();
    }
   
    public void formatHelpWith(final HelpFormatter formatter) {
        if (formatter == null) {
            throw new NullPointerException();
        }
        this.helpFormatter = formatter;
    }
   
    public Map<String, OptionSpec<?>> recognizedOptions() {
        return new HashMap<String, OptionSpec<?>>(this.recognizedOptions.toJavaUtilMap());
    }
   
    public OptionSet parse(final String... arguments) {
        final ArgumentList argumentList = new ArgumentList(arguments);
        final OptionSet detected = new OptionSet(this.recognizedOptions.toJavaUtilMap());
        detected.add(this.recognizedOptions.get("[arguments]"));
        while (argumentList.hasMore()) {
            this.state.handleArgument(this, argumentList, detected);
        }
        this.reset();
        this.ensureRequiredOptions(detected);
        return detected;
    }
   
    private void ensureRequiredOptions(final OptionSet options) {
        final Collection<String> missingRequiredOptions = this.missingRequiredOptions(options);
        final boolean helpOptionPresent = this.isHelpOptionPresent(options);
        if (!missingRequiredOptions.isEmpty() && !helpOptionPresent) {
            throw new MissingRequiredOptionException(missingRequiredOptions);
        }
    }
   
    private Collection<String> missingRequiredOptions(final OptionSet options) {
        final Collection<String> missingRequiredOptions = new HashSet<String>();
        for (final AbstractOptionSpec<?> each : this.recognizedOptions.toJavaUtilMap().values()) {
            if (each.isRequired() && !options.has(each)) {
                missingRequiredOptions.addAll(each.options());
            }
        }
        for (final Map.Entry<Collection<String>, Set<OptionSpec<?>>> eachEntry : this.requiredIf.entrySet()) {
            final AbstractOptionSpec<?> required = this.specFor(eachEntry.getKey().iterator().next());
            if (this.optionsHasAnyOf(options, eachEntry.getValue()) && !options.has(required)) {
                missingRequiredOptions.addAll(required.options());
            }
        }
        for (final Map.Entry<Collection<String>, Set<OptionSpec<?>>> eachEntry : this.requiredUnless.entrySet()) {
            final AbstractOptionSpec<?> required = this.specFor(eachEntry.getKey().iterator().next());
            if (!this.optionsHasAnyOf(options, eachEntry.getValue()) && !options.has(required)) {
                missingRequiredOptions.addAll(required.options());
            }
        }
        return missingRequiredOptions;
    }
   
    private boolean optionsHasAnyOf(final OptionSet options, final Collection<OptionSpec<?>> specs) {
        for (final OptionSpec<?> each : specs) {
            if (options.has(each)) {
                return true;
            }
        }
        return false;
    }
   
    private boolean isHelpOptionPresent(final OptionSet options) {
        boolean helpOptionPresent = false;
        for (final AbstractOptionSpec<?> each : this.recognizedOptions.toJavaUtilMap().values()) {
            if (each.isForHelp() && options.has(each)) {
                helpOptionPresent = true;
                break;
            }
        }
        return helpOptionPresent;
    }
   
    void handleLongOptionToken(final String candidate, final ArgumentList arguments, final OptionSet detected) {
        final KeyValuePair optionAndArgument = parseLongOptionWithArgument(candidate);
        if (!this.isRecognized(optionAndArgument.key)) {
            throw OptionException.unrecognizedOption(optionAndArgument.key);
        }
        final AbstractOptionSpec<?> optionSpec = this.specFor(optionAndArgument.key);
        optionSpec.handleOption(this, arguments, detected, optionAndArgument.value);
    }
   
    void handleShortOptionToken(final String candidate, final ArgumentList arguments, final OptionSet detected) {
        final KeyValuePair optionAndArgument = parseShortOptionWithArgument(candidate);
        if (this.isRecognized(optionAndArgument.key)) {
            this.specFor(optionAndArgument.key).handleOption(this, arguments, detected, optionAndArgument.value);
        }
        else {
            this.handleShortOptionCluster(candidate, arguments, detected);
        }
    }
   
    private void handleShortOptionCluster(final String candidate, final ArgumentList arguments, final OptionSet detected) {
        final char[] options = extractShortOptionsFrom(candidate);
        this.validateOptionCharacters(options);
        for (int i = 0; i < options.length; ++i) {
            final AbstractOptionSpec<?> optionSpec = this.specFor(options[i]);
            if (optionSpec.acceptsArguments() && options.length > i + 1) {
                final String detectedArgument = String.valueOf(options, i + 1, options.length - 1 - i);
                optionSpec.handleOption(this, arguments, detected, detectedArgument);
                break;
            }
            optionSpec.handleOption(this, arguments, detected, null);
        }
    }
   
    void handleNonOptionArgument(final String candidate, final ArgumentList arguments, final OptionSet detectedOptions) {
        this.specFor("[arguments]").handleOption(this, arguments, detectedOptions, candidate);
    }
   
    void noMoreOptions() {
        this.state = OptionParserState.noMoreOptions();
    }
   
    boolean looksLikeAnOption(final String argument) {
        return ParserRules.isShortOptionToken(argument) || ParserRules.isLongOptionToken(argument);
    }
   
    boolean isRecognized(final String option) {
        return this.recognizedOptions.contains(option);
    }
   
    void requiredIf(final Collection<String> precedentSynonyms, final String required) {
        this.requiredIf(precedentSynonyms, this.specFor(required));
    }
   
    void requiredIf(final Collection<String> precedentSynonyms, final OptionSpec<?> required) {
        this.putRequiredOption(precedentSynonyms, required, this.requiredIf);
    }
   
    void requiredUnless(final Collection<String> precedentSynonyms, final String required) {
        this.requiredUnless(precedentSynonyms, this.specFor(required));
    }
   
    void requiredUnless(final Collection<String> precedentSynonyms, final OptionSpec<?> required) {
        this.putRequiredOption(precedentSynonyms, required, this.requiredUnless);
    }
   
    private void putRequiredOption(final Collection<String> precedentSynonyms, final OptionSpec<?> required, final Map<Collection<String>, Set<OptionSpec<?>>> target) {
        for (final String each : precedentSynonyms) {
            final AbstractOptionSpec<?> spec = this.specFor(each);
            if (spec == null) {
                throw new UnconfiguredOptionException(precedentSynonyms);
            }
        }
        Set<OptionSpec<?>> associated = target.get(precedentSynonyms);
        if (associated == null) {
            associated = new HashSet<OptionSpec<?>>();
            target.put(precedentSynonyms, associated);
        }
        associated.add(required);
    }
   
    private AbstractOptionSpec<?> specFor(final char option) {
        return this.specFor(String.valueOf(option));
    }
   
    private AbstractOptionSpec<?> specFor(final String option) {
        return this.recognizedOptions.get(option);
    }
   
    private void reset() {
        this.state = OptionParserState.moreOptions(this.posixlyCorrect);
    }
   
    private static char[] extractShortOptionsFrom(final String argument) {
        final char[] options = new char[argument.length() - 1];
        argument.getChars(1, argument.length(), options, 0);
        return options;
    }
   
    private void validateOptionCharacters(final char[] options) {
        for (final char each : options) {
            final String option = String.valueOf(each);
            if (!this.isRecognized(option)) {
                throw OptionException.unrecognizedOption(option);
            }
            if (this.specFor(option).acceptsArguments()) {
                return;
            }
        }
    }
   
    private static KeyValuePair parseLongOptionWithArgument(final String argument) {
        return KeyValuePair.valueOf(argument.substring(2));
    }
   
    private static KeyValuePair parseShortOptionWithArgument(final String argument) {
        return KeyValuePair.valueOf(argument.substring(1));
    }
}
复制代码
②修改WPF:
对wpf进行脱壳破解,
  网易.zip (8.33 KB, 下载次数: 1) (部分泄露信息)

不信看这个源码:
链接:http://pan.baidu.com/s/1sloKoyT 密码:ecs5

0

主题

1

帖子

0

积分

Lv.1 新手木匠

UID
697970
小麦
0
金锭
4
下界之星
0
发表于 3 天前 | 显示全部楼层
我就想知道为什么我装了个jdk之后就启动不了游戏了

1

主题

2

帖子

2

积分

Lv.1 新手木匠

UID
2262529
小麦
0
金锭
4
下界之星
0
发表于 3 天前 | 显示全部楼层
启动了启动器之后没有反应,后台运行里有mc的install.exe进程,就算有了反应也是检查更新中,然后就跳出来更新失败,要求检查网络连接
重装过五遍了,每个盘都试过了
清理过dns缓存了,framework也重装过了

24

主题

117

帖子

53

积分

Lv.3 矿物能手

UID
665317
小麦
0
金锭
112
下界之星
0
发表于 3 天前 来自手机 | 显示全部楼层
萨满的技能明明显示可以卷起方块却不会有方块被卷起,而且萨满放技能根本看不见。我希望能把英勇的最高时间改成10秒,6秒太短了,狼可以改成12或15秒,希望增强。

0

主题

1

帖子

0

积分

Lv.1 新手木匠

UID
2258781
小麦
0
金锭
1
下界之星
0
发表于 3 天前 | 显示全部楼层
网易大大,我问一下你们 我们为什么明明不是防沉迷,但是我今天登录游戏就变成防沉迷了??
网易大大们,我们只是想要一个解释,请把我们的防沉迷去除,谢谢 用户名xzy3089695701@163.com   如果你们实在是无理取闹,那我只能把这个恶劣的事情报告国家游戏安全局了,不想网易和多玩我的世界一样破产的话,就取消的我们的防沉迷

1

主题

2

帖子

2

积分

Lv.1 新手木匠

UID
2190695
小麦
0
金锭
3
下界之星
0
发表于 3 天前 | 显示全部楼层
为什么登入时说操作失败
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

返回顶部