小编aka*_*okd的帖子

我正在研究一个实时太空战略游戏克隆,当时它没有任何多人游戏选项.我想添加多人游戏.

游戏本身相对较长:完成游戏需要大约10-15小时的游戏时间.这是非常长的,我不想强​​迫玩家不间断地玩,或者由于崩溃/停电而失去游戏状态.

类似的游戏如何解决这类问题？像单人游戏一样保存多人游戏？

在单人模式下,玩家可以暂停并加速模拟时间(在暂停模式下,玩家仍然可以发出命令,在行星上建立等等).

如何将此功能转换为多人游戏模式？

让我们假设有超过2个玩家(额外的AI或人类玩家)和一个玩家攻击另一个玩家将游戏切换到太空/地面战斗.这些战斗也可以暂停发布命令.

其他没有参与的球员应该怎么办？他们应该等吗？他们应该被迫只在自己的王国中运作吗？

更新:关于游戏的一些细节.

我正在克隆这个游戏.克隆作为开源发布,因此,可能会有人创建作弊版本.这是一个问题,但现在并不重要.我认为我通过在玩家之间移动游戏状态和控制来解决它:首先它在第一个玩家的机器上运行,然后移动到第二个等等.

我想更加强调上面的第三个问题:

当两个参与战斗时,其他玩家应该怎么做？

随着王国管理层的筛选,战斗在不同的屏幕上进行.在单人游戏模式中,战斗会自动停止游戏世界,玩家和AI都无法在战斗中管理其王国.

我有一个包含ASCII和Unicode字符的CSV文件.说"ÅÔÉA".我不确定这个文件的编码格式,但是当我在记事本中打开它时,它显示"ANSI"作为其编码标准.

我以UTF-8编码格式获取CSV的这些内容.

fr = new InputStreamReader(new FileInputStream(fileName),"UTF-8");

但是当我将它存储在DB中时,这些特殊字符("A"除外)不能正确存储.人物变得混乱

我希望所有的角色都能妥善存放.任何的想法？

我想使用Scala Actor框架进行包含大约10.000个代理(机器和产品代理)的多代理模拟.

据我所知,如果有很多演员传递消息,它会因递归而耗尽堆栈吗？

如果是这样,我如何增加底层工作线程的堆栈大小？

我想在运行时使用反射来获取集合的泛型类型.

代码(JAVA):

Field collectionObject = object.getClass().getDeclaredField(
    collectionField.getName());
//here I compare to see if a collection
if (Collection.class.isAssignableFrom(collectionObject.getType())) {
   // here I have to use the generic type of the collection 
   // to see if it's from a specific type - in this case Persistable
   if (Persistable.class.isAssignableFrom(GENERIC_TYPE_COLLECTION.class)) {
   }
}

有没有办法在运行时在java中获取集合的泛型类型？在我的情况下,我需要集合的泛型类型.class.

提前致谢!

首先让我向SO社区道歉,告诉你一些应该是如此微不足道的东西.但是我整天都在这里,而且我已经走到了尽头.

我的程序中有一部分需要从输入流中提取文本,以及使用Runtime.getrunTime().exec()启动的进程的错误流,并以有序的方式将其传递给标准输入和输出.我有一个功能,因为我可以告诉应该工作.但它似乎陷入了陷阱 - 它正在等待流报告准备好 - 但流已经完成并且没有报告.我很困惑.我想不出另一种方法可以做到这符合我的约束,而我更加怀疑这样的捕获22可以存在.

这是我的代码:

private void forwardStreamtoStd(InputStream in, InputStream err) 
throws IOException {
    int c = -1;
    BufferedReader inReader = new BufferedReader(
        new InputStreamReader(in, "US-ASCII"));
    BufferedReader errReader = new BufferedReader(
        new InputStreamReader(err, "US-ASCII"));
    boolean inFinished = false, errFinished = false;

    try {
        System.out.println("Begin stream read loop...");
        while (!inFinished && !errFinished) {
        if (!inFinished) {
            while (inReader.ready()) {
                if ((c = inReader.read()) == -1) {
                    inFinished = true;
                } 
                else {
                    System.out.print((char) c);
                }
            }
        }

        if (!errFinished) …

我正在构建一个 Android 应用程序，使用 Android Room 作为持久层和 RxJava 2。

在我的 UI 中，我订阅了 Room dao 返回的 Flowable：

MainActivity.java

mTaskViewModel.getTasksForDay(SessionManager.getInstance(this).getUser().getId(), CalendarManager.getInstance().getDayString(CalendarManager.getInstance().getSelectedDate()))
                        .subscribeOn(Schedulers.io())
                        .observeOn(AndroidSchedulers.mainThread())
                        .subscribe(taskModelsSubscriber);

MainActivity 中的订阅者

private Subscriber<List<Task>> taskModelsSubscriber = new Subscriber<List<Task>>() {
        @Override
        public void onSubscribe(Subscription s) {
            s.request(Long.MAX_VALUE);
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    mRefreshLayout.setRefreshing(true);
                }
            });
        }

        @Override
        public void onNext(List<Task> tasks) {
            mTasksList = tasks;
            scheduleNotifications();
            Collections.sort(mTasksList);

            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    TaskArrayAdapter taskArrayAdapter = new TaskArrayAdapter(MainActivity.this, mTasksList, SessionManager.getInstance(getApplicationContext()).getUser());
                    tasksListView.setAdapter(taskArrayAdapter);
                    mRefreshLayout.setRefreshing(false);
                }
            });
        } …

我有一个小型图像处理应用程序,它使用SwingWorker一次完成多项任务.但是,如果我运行以下代码(过度简化的摘录),它只挂在JDK 7 b70(Windows)上,但在6u16中工作.它在另一个工作者中启动一个新工作者并等待其结果(真正的应用程序运行多个子工作者并等待所有这些方式).我是否在这里使用了一些错误的模式(因为在swingworker-pool中大多有3-5名工人,我认为其限制为10)？

import javax.swing.SwingUtilities;
import javax.swing.SwingWorker;

public class Swing {
       static SwingWorker<String, Void> getWorker2() {
               return new SwingWorker<String, Void>() {
                       @Override
                       protected String doInBackground() throws Exception {
                               return "Hello World";
                       }
               };
       }
       static void runWorker() {
               SwingWorker<String, Void> worker 
                   = new SwingWorker<String, Void>() {
                       @Override
                       protected String doInBackground() throws Exception {
                               SwingWorker<String, Void> sw2 = getWorker2();
                               sw2.execute();
                               return sw2.get();
                       }
               };
               worker.execute();
               try {
                       System.out.println(worker.get());
               } catch (Exception e) {
                       e.printStackTrace();
               }
       }
       public static void main(String[] args) …

我想在 Java 中播放 WAV 声音（某些自定义视频格式的音轨），但是，我在使用 Clip 时遇到了麻烦：似乎一次只能听到一个实例。因此，我切换到普通的旧 SourceDataLine 方式。

在这种情况下，我想在视频暂停和取消暂停时暂停和恢复音频。很遗憾。当我在 SDL 上调用 stop() 时，播放线程完全完成并且声音缓冲区被清空：

sdl.open();
sdl.start();
sdl.write(dataBuffer);
sdl.drain();
sdl.stop();

当音频线程在 write() 或排出() 上阻塞时发出异步 stop() 实际上会丢失播放位置。

如何以阻塞方式暂停 SourceDataLine，和/或如何知道已通过它播放了多少音频以使用 write(databuffer,skip,len) 进行恢复？

我有以下代码片段Func0和Action1使用.

Observable.defer(new Func0<Observable<String>>() {
    @Override
    public Observable<String> call() {
        try {
            return Observable.just(Database.readValue());       
        }
        catch(IOException e) {
            return Observable.error(e);     
        }   
    })
    .subscribe(new Action1<String>() {
        @Override
        public void call(String result) {
            resultTextView.setText(result);     
        }   
    }
}

但我只是想知道它们之间有什么区别.我知道数字表示参数的数量,即Func0没有参数,Action1有1个参数.

但是,你怎么知道使用哪一个？我应该使用Action或Func.

该call方法的目的是什么？

非常感谢任何建议,

我有一串弦。对于每个字符串，我必须进行远程调用。但问题是，进行远程调用的方法实际上返回了 Mono 响应（显然，因为对应于单个请求，所以将有单个响应）。

处理此类情况的正确模式应该是什么？我能想到的一种解决方案是对流元素进行串行（或并行）调用，并将响应减少为单个响应并返回。

这是代码：

fluxObj.flatmap(a -> makeRemoteCall(a)//converts the Mono of the response to a Flux).reduce(...)

我无法将头转入 . 该flatmap方法makeRemoteCall返回一个Mono. 但返回的是响应的flatmapa 。Flux首先，为什么会发生这种情况？其次，这是否意味着返回Flux包含单个响应对象（在 中返回Mono）？