Example #1
0
  public PlanetMap(String s, ChildForm parent, GameProxy gameProxy) {
    // super(false);
    this.parent = parent;
    this.gameProxy = gameProxy;
    // System.out.println("my p " + myPlanet);
    this.addCommand(cmdBack);
    // this.addCommand(cmdBuild);
    this.setCommandListener(this);
    setFullScreenMode(true);
    System.out.println("11111");
    en = Ground.getEnvironment(gameProxy.getMap(), gameProxy.getSaveName());
    System.out.println("21111");
    System.out.println(en);
    ENV = en;
    cm = new CurserManager(en, getHeight(), getWidth(), gameProxy);
    um = new UnitManager(en, getHeight(), getWidth());
    System.out.println("##1");
    cm.setUm(um);
    exec = true;
    myThread = new Thread(this);
    System.out.println("##2");

    try {
      JCageConfigurator.scoreTable = new Hashtable();
      System.out.println("Starting...");
      myThread.start();
      System.out.println("started...");
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
Example #2
0
 private void renderGround(GL2 g) {
   if ((Globals.upCamera && Globals.floor >= 0 && Globals.floor < 3) || !Globals.upCamera) {
     if (Globals.upCamera && Globals.floor >= 0 && Globals.floor < 3) {
       switch (Globals.floor) {
         case 0:
           g.glColor3f(1, 1, 1);
           break;
         case 1:
           g.glColor3f(0.6f, 0.6f, 0.6f);
           break;
         case 2:
           g.glColor3f(0.25f, 0.25f, 0.25f);
           break;
       }
     }
     ground.render(g, this);
   }
 }
  public void onDraw(Canvas canvas) {
    int width = canvas.getWidth();
    int height = canvas.getHeight();

    if (droid == null) {
      Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.droid);
      droid = new Droid(bitmap, 0, 0, this);
    }

    if (ground == null) {
      ground = new Ground(0, height - START_GROUND_HEIGHT, width, height);
    }

    // canvas.drawBitmap(droidBitmap, 0,0,PAINT);
    droid.move();
    droid.draw(canvas);
    ground.draw(canvas);
    invalidate();
  }
Example #4
0
  protected static void generateGround() {
    Ground.setNumberOfRect(200);

    Ground.generateTerrain();
    myRect = Ground.getListGround();
  }
Example #5
0
  public void serialize(Document doc, Element root) {
    Element tile = doc.createElement("tile");
    tile.setAttribute("x", Integer.toString(x));
    tile.setAttribute("y", Integer.toString(y));
    tile.setAttribute("height", Float.toString(height));
    tile.setAttribute("caveHeight", Float.toString(caveHeight));
    tile.setAttribute("caveSize", Float.toString(caveSize));
    root.appendChild(tile);

    ground.serialize(doc, tile);
    cave.serialize(doc, tile);
    if (label != null) {
      label.serialize(doc, tile, false);
    }
    if (caveLabel != null) {
      caveLabel.serialize(doc, tile, true);
    }

    final HashMap<Integer, Element> levels = new HashMap<>();

    for (Entry<EntityData, TileEntity> e : entities.entrySet()) {
      final EntityData key = e.getKey();
      final TileEntity entity = e.getValue();
      final int floor = key.getFloor();

      Element level = levels.get(floor);
      if (level == null) {
        level = doc.createElement("level");
        level.setAttribute("value", Integer.toString(key.getFloor()));
        levels.put(key.getFloor(), level);
        tile.appendChild(level);
      }

      switch (key.getType()) {
        case FLOORROOF:
          entity.serialize(doc, level);
          break;
        case HWALL:
        case HFENCE:
          Element hWall = doc.createElement("hWall");
          entity.serialize(doc, hWall);
          level.appendChild(hWall);
          break;
        case VWALL:
        case VFENCE:
          Element vWall = doc.createElement("vWall");
          entity.serialize(doc, vWall);
          level.appendChild(vWall);
          break;
        case HBORDER:
          Element hDeco = doc.createElement("hBorder");
          entity.serialize(doc, hDeco);
          level.appendChild(hDeco);
          break;
        case VBORDER:
          Element vDeco = doc.createElement("vBorder");
          entity.serialize(doc, vDeco);
          level.appendChild(vDeco);
          break;
        case OBJECT:
          ObjectEntityData objectData = (ObjectEntityData) key;
          Element objectElement = doc.createElement("object");
          objectElement.setAttribute("position", objectData.getLocation().toString());
          entity.serialize(doc, objectElement);
          level.appendChild(objectElement);
          break;
      }
    }
  }
Example #6
0
  public void init() throws ControlFlow {
    Base.init(base);
    DefaultBehavior.init(defaultBehavior);
    Mixins.init(mixins);
    system.init();
    Runtime.initRuntime(runtime);
    message.init();
    Ground.init(iokeGround, ground);
    Origin.init(origin);
    nil.init();
    _true.init();
    _false.init();
    text.init();
    symbol.init();
    number.init();
    range.init();
    pair.init();
    tuple.init();
    dateTime.init();
    lexicalContext.init();
    list.init();
    dict.init();
    set.init();
    call.init();
    Locals.init(locals);
    Condition.init(condition);
    Rescue.init(rescue);
    Handler.init(handler);
    io.init();
    FileSystem.init(fileSystem);
    regexp.init();
    JavaGround.init(javaGround);
    JavaArray.init(javaArray);
    javaWrapper.init();

    iokeGround.mimicsWithoutCheck(defaultBehavior);
    iokeGround.mimicsWithoutCheck(base);
    ground.mimicsWithoutCheck(iokeGround);
    ground.mimicsWithoutCheck(javaGround);
    origin.mimicsWithoutCheck(ground);

    mixins.mimicsWithoutCheck(defaultBehavior);

    system.mimicsWithoutCheck(ground);
    system.mimicsWithoutCheck(defaultBehavior);
    runtime.mimicsWithoutCheck(ground);
    runtime.mimicsWithoutCheck(defaultBehavior);

    nil.mimicsWithoutCheck(origin);
    _true.mimicsWithoutCheck(origin);
    _false.mimicsWithoutCheck(origin);
    text.mimicsWithoutCheck(origin);
    symbol.mimicsWithoutCheck(origin);
    number.mimicsWithoutCheck(origin);
    range.mimicsWithoutCheck(origin);
    pair.mimicsWithoutCheck(origin);
    dateTime.mimicsWithoutCheck(origin);

    message.mimicsWithoutCheck(origin);
    method.mimicsWithoutCheck(origin);

    list.mimicsWithoutCheck(origin);
    dict.mimicsWithoutCheck(origin);
    set.mimicsWithoutCheck(origin);

    condition.mimicsWithoutCheck(origin);
    rescue.mimicsWithoutCheck(origin);
    handler.mimicsWithoutCheck(origin);

    io.mimicsWithoutCheck(origin);

    fileSystem.mimicsWithoutCheck(origin);

    regexp.mimicsWithoutCheck(origin);

    method.init();
    defaultMethod.init();
    nativeMethod.init();
    lexicalBlock.init();
    defaultMacro.init();
    lexicalMacro.init();
    defaultSyntax.init();
    arity.init();
    call.mimicsWithoutCheck(origin);

    method.mimicsWithoutCheck(origin);
    defaultMethod.mimicsWithoutCheck(method);
    nativeMethod.mimicsWithoutCheck(method);
    defaultMacro.mimicsWithoutCheck(origin);
    lexicalMacro.mimicsWithoutCheck(origin);
    defaultSyntax.mimicsWithoutCheck(origin);
    arity.mimicsWithoutCheck(origin);
    lexicalBlock.mimicsWithoutCheck(origin);

    Restart.init(restart);
    restart.mimicsWithoutCheck(origin);

    javaWrapper.mimicsWithoutCheck(origin);

    Reflector.init(this);
    Hook.init(this);

    Sequence.init(sequence);
    iteratorSequence.init();
    keyValueIteratorSequence.init();

    addBuiltinScript(
        "benchmark",
        new Builtin() {
          public IokeObject load(Runtime runtime, IokeObject context, IokeObject message)
              throws ControlFlow {
            return ioke.lang.extensions.benchmark.Benchmark.create(runtime);
          }
        });

    addBuiltinScript(
        "readline",
        new Builtin() {
          public IokeObject load(Runtime runtime, IokeObject context, IokeObject message)
              throws ControlFlow {
            return ioke.lang.extensions.readline.Readline.create(runtime);
          }
        });

    try {
      evaluateString("use(\"builtin/A05_conditions\")", message, ground);
      evaluateString("use(\"builtin/A10_defaultBehavior\")", message, ground);
      evaluateString("use(\"builtin/A15_dmacro\")", message, ground);
      evaluateString("use(\"builtin/A20_comparing\")", message, ground);
      evaluateString("use(\"builtin/A25_defaultBehavior_inspection\")", message, ground);
      evaluateString("use(\"builtin/A30_system\")", message, ground);

      evaluateString("use(\"builtin/D05_number\")", message, ground);
      evaluateString("use(\"builtin/D10_call\")", message, ground);
      evaluateString("use(\"builtin/D15_range\")", message, ground);
      evaluateString("use(\"builtin/D20_booleans\")", message, ground);
      evaluateString("use(\"builtin/D25_list\")", message, ground);
      evaluateString("use(\"builtin/D30_dict\")", message, ground);
      evaluateString("use(\"builtin/D35_pair\")", message, ground);
      evaluateString("use(\"builtin/D37_tuple\")", message, ground);
      evaluateString("use(\"builtin/D40_text\")", message, ground);
      evaluateString("use(\"builtin/D43_regexp\")", message, ground);
      evaluateString("use(\"builtin/D45_fileSystem\")", message, ground);
      evaluateString("use(\"builtin/D50_runtime\")", message, ground);

      evaluateString("use(\"builtin/F05_case\")", message, ground);
      evaluateString("use(\"builtin/F10_comprehensions\")", message, ground);
      evaluateString("use(\"builtin/F15_message\")", message, ground);
      evaluateString("use(\"builtin/F20_set\")", message, ground);
      evaluateString("use(\"builtin/F25_cond\")", message, ground);
      evaluateString("use(\"builtin/F30_enumerable\")", message, ground);
      evaluateString("use(\"builtin/F32_sequence\")", message, ground);

      evaluateString("use(\"builtin/G05_aspects\")", message, ground);
      evaluateString("use(\"builtin/G10_origin\")", message, ground);
      evaluateString("use(\"builtin/G10_arity\")", message, ground);

      evaluateString("use(\"builtin/G50_hook\")", message, ground);

      evaluateString("use(\"builtin/H10_lexicalBlock\")", message, ground);

      evaluateString("use(\"builtin/J05_javaGround\")", message, ground);
    } catch (ControlFlow cf) {
    }
  }