小编gil*_*och的帖子

我需要两个可以访问彼此私有的实例.我天生就想到了一个伴侣对象,它允许访问它的同伴类的唯一实例.这个类本身是私有的,因此用户不能只使用创建实例new.

object A {
    def apply = dual
    lazy val dual = new A
}

private class A {
    //some irrelevant logic...
}

此代码无法编译.我得到:类A逃避其定义范围作为类型A错误的一部分,我真的不明白.我当前的解决方法是使用类应该具有的每个方法声明来定义特征并使class A该特性扩展,而双重属于特征类型,而不是class A类型.

我在这里缺少什么理论问题？为什么这是禁止的？

我用以下方式使用ansible:

ansible-playbook -f 1 my-play-book.yaml --ask-pass --ask-sudo-pass

在此之后,我被要求输入ssh和sudo密码(两者的密码相同).

在我的playbook文件中,我正在使用同步任务:

synchronize: mode=push src=rel/path/myfolder/ dest=/abs/path/myfolder/

对于每个主机,我被提示输入远程主机的ssh密码(与我在playbook运行开始时输入的密码相同)

如何在执行同步任务时避免输入密码？

如何使用播放框架发送一个美化的json响应？我想有一个查询参数__CODE__,当它被提供时,json响应将被打印出来.

考虑一些示例代码:

def handleGET(path:String) = Action{ implicit request =>
  val json = doSomethingThatReturnsAJson(path,request)
  request.getQueryString("pretty") match {
    case Some(_) => //some magic that will beautify the response
    case None => Ok(json)
  }
}

如何才能完成魔术？我的搜索让我 看到了json pretty print,这对它本身并不是很有帮助,但它确实表示在未来的版本中应该集成abillity.这是在谈论2.1.X,所以,我猜它已经存在于2.2X版本的游戏中.

我一直想写它一段时间......作为大学的一个项目,我(和朋友一起)写了一个需要良好爆炸和粒子效果的游戏.我们遇到了一些问题,我们很优雅地解决了这个问题(我想),我想分享这些知识.

好的,所以我们找到了这个教程:制作一个粒子爆炸效果,这似乎很容易用Java和JOGL实现.在我回答我们究竟是如何实现本教程之前,我将解释如何完成渲染:

相机:只是一个标准正交基础,它基本上意味着它包含3个归一化的正交矢量,以及表示摄像机位置的第4个矢量.渲染完成使用gluLookAt:

glu.gluLookAt(cam.getPosition().getX(), cam.getPosition().getY(), cam.getPosition().getZ(), 
              cam.getZ_Vector().getX(), cam.getZ_Vector().getY(), cam.getZ_Vector().getZ(), 
              cam.getY_Vector().getX(), cam.getY_Vector().getY(), cam.getY_Vector().getZ());

这样摄像机的z矢量实际上是目标,y矢量是"向上"矢量,而位置是......好位置.

所以(如果把它放在一个问题风格),如何实现良好的粒子效果？

PS:所有代码示例和游戏中的截图(包括答案​​和问题)均来自游戏,该游戏位于此处:Astroid Shooter

考虑以下json:

{
  "type":"A1",
  "system":{
    "path":"/example.org/FooBar",
    "lastModified":"2013-10-01T12:00:00Z"
  },
  "fields":{
    "foo1":["bar1"],
    "foo2":["bar2"],
    "foo3":["bar3"]
  }
}

现在,使用lift-json,我想将此json更改为:

{
  "type":"A1",
  "system":{
    "path":"/example.org/FooBar",
    "lastModified":"2013-10-01T12:00:00Z"
  },
  "fields":{
    "foo1":["bar1"],
    "foo2":["bar2"],
    "foo3":["bar3"]
  },
  "injected":{
    "bar1":"foo1",
    "bar2":"foo2"
  }
}

所以,我尝试了以下内容:

scala> val json = parse("""
     |{
     |  "type":"A1",
     |  "system":{
     |    "path":"/example.org/FooBar",
     |    "lastModified":"2013-10-01T12:00:00Z"
     |  },
     |  "fields":{
     |    "foo1":["bar1"],
     |    "foo2":["bar2"],
     |    "foo3":["bar3"]
     |  }
     |}""")

json: net.liftweb.json.JValue = JObject(List(JField(type,JString(A1)), JField(system,JObject(List(JField(path,JString(/example.org/FooBar)), JField(lastModified,JString(2013-10-01T12:00:00Z))))), JField(fields,JObject(List(JField(foo1,JArray(List(JString(bar1)))), JField(foo2,JArray(List(JString(bar2)))), JField(foo3,JArray(List(JString(bar3)))))))))

scala> json transform{case JObject(l) => JObject(l ::: List(JField("injected", ("bar1" -> "foo1") ~ ("bar2" …

我们正在写一个简单的3D游戏作为我们在大学学习的课程.(分配给夫妻)我们必须使用JOGL,所以我必须使用这个API(解决方案如:切换到更高级别的API,如java3D对我不好......)无论如何,我们决定的游戏实现是某种3D射击游戏.(到目前为止,我们为同一课程的上一个作业分配的代码可以在这里找到:http://code.google.com/p/mirzhcode/source/browse/？repo = cgex4)现在我我试图处理"特效".更准确地说,粒子和精灵(用于射击,爆炸等......)我遇到了关于精灵发射器的解释,我想实现:http://bit.ly/KrrPM4

我开始时似乎很容易.冲击波环,由一个快速生长的精灵组成.当我试图绘制我制作的图像时,我得到黑色背景而不是我想要的透明度.纹理图像是一个透明的png文件(所以有一个alpha通道) 我得到的是: 我用来生成这个代码:

在init()方法中:

//loading textures
try {
    shockwave = TextureIO.newTexture(new File( "textures/shockwave_128X128.png" ),false);
} catch (GLException e) {
    e.printStackTrace();
} catch (IOException e) {
    e.printStackTrace();
}

gl.glShadeModel(GL.GL_SMOOTH);
gl.glClearColor(0f, 0f, 0f, 1f);
gl.glClearDepth(1.0);
gl.glEnable(GL.GL_BLEND);
gl.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE);
gl.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST);
gl.glHint(GL.GL_POINT_SMOOTH_HINT, GL.GL_NICEST);
gl.glEnable(GL.GL_TEXTURE_2D);
gl.glEnable(GL.GL_DEPTH_TEST);

//UNCOMMENT THE FOLLOWING LINE OF CODE
//FOR REALISTIC COLORS. NOTE THAT ICC
//BUTTON WON'T CHANGE THE COLORS ANYMORE.

//gl.glEnable(GL.GL_LIGHTING);

//two (soft) lights …

我在扩展的对象中遇到了一些bizzar行为App.看看以下REPL命令:

scala> object A extends App {val x = "I am null"}
defined module A

scala> object B {val x = "I am a string"}
defined module B

scala> A.x
res0: java.lang.String = null

scala> B.x
res1: java.lang.String = I am a string

好吧,这有点奇怪......但它变得更加怪异.然后我认为vals object进入一些懒惰的评估...所以我尝试了一个真实的lazy val:

scala> object C extends App {lazy val x = "What am I?"}
defined module C

scala> C.x
res2: java.lang.String = What am I?

那么这里发生了什么？为什么常规val获得空值？
当我使用时,为什么这种行为会改变lazy val？
这个 …

一个描述我的问题的简单代码示例:

import scala.util._
import scala.concurrent._
import scala.concurrent.duration._
import ExecutionContext.Implicits.global

class LoserException(msg: String, dice: Int) extends Exception(msg) { def diceRoll: Int = dice }

def aPlayThatMayFail: Future[Int] = {
    Thread.sleep(1000) //throwing a dice takes some time...
    //throw a dice:
    (1 + Random.nextInt(6)) match {
        case 6 => Future.successful(6) //I win!
        case i: Int => Future.failed(new LoserException("I did not get 6...", i))
    }
}

def win(prefix: String): String = {
    val futureGameLog = aPlayThatMayFail
    futureGameLog.onComplete(t => t match {
        case Success(diceRoll) => …

我需要在我的项目中使用tools.jar,但将它打包在jar中没有多大意义,因为用户已经拥有它.那么,是否有可能将其用作"动态依赖"？意思是,我希望我的代码可以通过使用我的文件来编译,但我不希望它与它一起打包.我可以确保在运行时使用双重激活将其添加到类路径中,而不是使用用户.例如:tools.jar JAVA_HOME JAVA_HOME

object Main1 extends App {
    val myjar = Main1.getClass.getProtectionDomain.getCodeSource.getLocation.getFile
    val tools = System.getProperty("java.home").dropRight(3)+"lib/tools.jar" // drop "jre"
    val arguments = Array("java", "-cp", myjar+":"+tools, "me.myapp.Main2") ++ args
    val p = Runtime.getRuntime.exec(arguments)
    p.getErrorStream.close
    p.getOutputStream.close
}

仅供参考:我在独立的jar文件中使用程序集插件打包应用程序.

编辑:

一个丑陋的解决方案是将tools.jar文件复制到我的项目中的lib目录,并添加:

excludedJars in assembly <<= (fullClasspath in assembly) map { cp => 
    cp filter {_.data.getName == "tools.jar"}
}

在build.sbt 没有复制jar文件的情况下可以更优雅地完成吗？切换JVM会更容易,并tools.jar自动使用"正确"的文件......

说你给出的一个实例List[Class[_ <: Base]],并说许多类扩展Base:

class A extends Base
class B extends Base
class C extends A

等等......
现在,给定的列表可能只包含一些类.例如:val classes = classOf[A] :: Nil嗯,如果我val的类是在列表中找到的类型,或者如果它是列表中类的子类,我如何测试实例化？即如何实施:
def testClass(class : List[Class[_ <: Base]], instance : Base) : Boolean
何时:

val classes = classOf[A] :: Nil
testClass(classes, new A) // should return true
testClass(classes, new B) // should return false
testClass(classes, new C) // should return true

用例:
我正在尝试编写一个通用的重试模式,即获取一些非常容易出错的代码,并且我想重试执行一些最大次数的尝试,当每次失败时,它应该执行一些"等待" " 方法.
例如

retryRequest({
    //Some code that …

Lets say I want to have a Stream of squares. A simple way to declare it would be:

scala> def squares(n: Int): Stream[Int] = n * n #:: squares(n + 1)

But doing so, yields an error:

<console>:8: error: overloaded method value * with alternatives:
  (x: Double)Double <and>
  (x: Float)Float <and>
  (x: Long)Long <and>
  (x: Int)Int <and>
  (x: Char)Int <and>
  (x: Short)Int <and>
  (x: Byte)Int
 cannot be applied to (scala.collection.immutable.Stream[Int])
       def squares(n: Int): Stream[Int] = n * n #:: squares(n …