private void handlePressurePlateEvents() {
    Set<Vector3i> toRemoveSignal = Sets.newHashSet(activatedPressurePlates);

    Iterable<EntityRef> players =
        entityManager.getEntitiesWith(CharacterComponent.class, LocationComponent.class);
    for (EntityRef player : players) {
      Vector3f playerLocation = player.getComponent(LocationComponent.class).getWorldPosition();
      Vector3i locationBeneathPlayer =
          new Vector3i(playerLocation.x + 0.5f, playerLocation.y - 0.5f, playerLocation.z + 0.5f);
      Block blockBeneathPlayer = worldProvider.getBlock(locationBeneathPlayer);
      if (blockBeneathPlayer == signalPressurePlate) {
        EntityRef entityBeneathPlayer = blockEntityRegistry.getBlockEntityAt(locationBeneathPlayer);
        SignalProducerComponent signalProducer =
            entityBeneathPlayer.getComponent(SignalProducerComponent.class);
        if (signalProducer != null) {
          if (signalProducer.signalStrength == 0) {
            startProducingSignal(entityBeneathPlayer, -1);
            activatedPressurePlates.add(locationBeneathPlayer);
          } else {
            toRemoveSignal.remove(locationBeneathPlayer);
          }
        }
      }
    }

    for (Vector3i pressurePlateLocation : toRemoveSignal) {
      EntityRef pressurePlate = blockEntityRegistry.getBlockEntityAt(pressurePlateLocation);
      SignalProducerComponent signalProducer =
          pressurePlate.getComponent(SignalProducerComponent.class);
      if (signalProducer != null) {
        stopProducingSignal(pressurePlate);
        activatedPressurePlates.remove(pressurePlateLocation);
      }
    }
  }
Example #2
0
  @ReceiveEvent(components = {FenceGateComponent.class})
  public void onActivate(ActivateEvent event, EntityRef entity) {
    FenceGateComponent fenceGateComponent = entity.getComponent(FenceGateComponent.class);
    fenceGateComponent.isClosed = !fenceGateComponent.isClosed;
    entity.saveComponent(fenceGateComponent);

    BlockComponent blockComp = entity.getComponent(BlockComponent.class);
    if (blockComp == null) {
      event.cancel();
      return;
    }

    Vector3i primePos = new Vector3i(blockComp.getPosition());
    Block primeBlock = worldProvider.getBlock(primePos);

    Block newBlock = null;
    if (fenceGateComponent.isClosed) {
      newBlock =
          BlockManager.getInstance()
              .getBlockFamily("fences:FenceGateClosed")
              .getBlockForPlacing(worldProvider, primePos, primeBlock.getDirection(), Side.FRONT);
    } else {
      newBlock =
          BlockManager.getInstance()
              .getBlockFamily("fences:FenceGateOpen")
              .getBlockForPlacing(worldProvider, primePos, primeBlock.getDirection(), Side.FRONT);
    }

    if (newBlock != null) {
      blockEntityRegistry.setBlock(primePos, newBlock, primeBlock, entity);
    }
  }
Example #3
0
 private void updateEntity(NetData.UpdateEntityMessage updateEntity) {
   EntityRef currentEntity = networkSystem.getEntity(updateEntity.getNetId());
   if (currentEntity.exists()) {
     NetworkComponent netComp = currentEntity.getComponent(NetworkComponent.class);
     if (netComp == null) {
       logger.error(
           "Updating entity with no network component: {}, expected netId {}",
           currentEntity,
           updateEntity.getNetId());
       return;
     }
     if (netComp.getNetworkId() != updateEntity.getNetId()) {
       logger.error("Network ID wrong before update");
     }
     boolean blockEntityBefore = currentEntity.hasComponent(BlockComponent.class);
     entitySerializer.deserializeOnto(currentEntity, updateEntity.getEntity());
     BlockComponent blockComponent = currentEntity.getComponent(BlockComponent.class);
     if (blockComponent != null && !blockEntityBefore) {
       if (!blockEntityRegistry
           .getExistingBlockEntityAt(blockComponent.getPosition())
           .equals(currentEntity)) {
         logger.error("Failed to associated new block entity");
       }
     }
     if (netComp.getNetworkId() != updateEntity.getNetId()) {
       logger.error(
           "Network ID lost in update: {}, {} -> {}",
           currentEntity,
           updateEntity.getNetId(),
           netComp.getNetworkId());
     }
   } else {
     logger.warn("Received update for non-existent entity {}", updateEntity.getNetId());
   }
 }
 // Generates all non-temporary block entities
 private void generateBlockEntities(Chunk chunk) {
   ChunkBlockIterator i = chunk.getBlockIterator();
   while (i.next()) {
     if (i.getBlock().isKeepActive()) {
       registry.getBlockEntityAt(i.getBlockPos());
     }
   }
 }
    @Override
    public boolean isConnectingTo(
        Vector3i blockLocation,
        Side connectSide,
        WorldProvider worldProvider,
        BlockEntityRegistry blockEntityRegistry) {
      Vector3i neighborLocation = new Vector3i(blockLocation);
      neighborLocation.add(connectSide.getVector3i());

      EntityRef neighborEntity = blockEntityRegistry.getBlockEntityAt(neighborLocation);
      return neighborEntity != null && connectsToNeighbor(neighborEntity);
    }
  private void handleDelayedActionsEvents() {
    long worldTime = time.getGameTimeInMs();
    BlockAtLocationDelayedAction action;
    while ((action = delayedActions.peek()) != null && action.executeTime <= worldTime) {
      action = delayedActions.poll();

      final Vector3i actionLocation = action.blockLocation.toVector3i();
      if (worldProvider.isBlockRelevant(actionLocation)) {
        final Block block = worldProvider.getBlock(actionLocation);
        final BlockFamily blockFamily = block.getBlockFamily();

        final EntityRef blockEntity = blockEntityRegistry.getBlockEntityAt(actionLocation);

        if (blockFamily == signalOnDelayGate) {
          startProducingSignal(blockEntity, -1);
        } else if (blockFamily == signalOffDelayGate) {
          stopProducingSignal(blockEntity);
        } else if (blockFamily == signalOrGate
            || blockFamily == signalAndGate
            || blockFamily == signalXorGate) {
          if (processOutputForNormalGate(blockEntity)) {
            gateLastSignalChangeTime.put(new ImmutableBlockLocation(actionLocation), worldTime);
          }
        } else if (blockFamily == signalNandGate) {
          if (processOutputForRevertedGate(blockEntity)) {
            gateLastSignalChangeTime.put(new ImmutableBlockLocation(actionLocation), worldTime);
          }
        } else if (blockFamily == signalSetResetGate) {
          if (processOutputForSetResetGate(blockEntity)) {
            gateLastSignalChangeTime.put(new ImmutableBlockLocation(actionLocation), worldTime);
          }
        } else if (block == signalButton) {
          stopProducingSignal(blockEntity);
        }

        blockEntity.removeComponent(SignalDelayedActionComponent.class);
      } else {
        // TODO Remove this workaround when BlockEntities will be stored with the chunk they belong
        // to
        action.executeTime += NOT_LOADED_BLOCK_RETRY_DELAY;
        delayedActions.add(action);
      }
    }
  }
Example #7
0
 private void processEvent(NetData.EventMessage message) {
   try {
     Event event = eventSerializer.deserialize(message.getEvent());
     EntityRef target = EntityRef.NULL;
     if (message.hasTargetBlockPos()) {
       target =
           blockEntityRegistry.getBlockEntityAt(
               NetMessageUtil.convert(message.getTargetBlockPos()));
     } else if (message.hasTargetId()) {
       target = networkSystem.getEntity(message.getTargetId());
     }
     if (target.exists()) {
       target.send(event);
     } else {
       logger.info(
           "Dropping event {} for unavailable entity {}",
           event.getClass().getSimpleName(),
           target);
     }
   } catch (DeserializationException e) {
     logger.error("Failed to deserialize event", e);
   }
 }
Example #8
0
  @ReceiveEvent
  public void onActivate(
      ActivateEvent event, EntityRef entity, TunnelActionComponent tunnelActionComponent) {

    Vector3f dir = new Vector3f(event.getDirection());
    dir.scale(4.0f);
    Vector3f origin = new Vector3f(event.getOrigin());
    origin.add(dir);
    Vector3i blockPos = new Vector3i();

    int particleEffects = 0;
    int blockCounter = tunnelActionComponent.maxDestroyedBlocks;
    for (int s = 0; s <= tunnelActionComponent.maxTunnelDepth; s++) {
      origin.add(dir);
      if (!worldProvider.isBlockRelevant(origin)) {
        break;
      }

      for (int i = 0; i < tunnelActionComponent.maxRaysCast; i++) {
        Vector3f direction = random.nextVector3f();
        Vector3f impulse = new Vector3f(direction);
        impulse.scale(tunnelActionComponent.explosiveForce);

        for (int j = 0; j < 3; j++) {
          Vector3f target = new Vector3f(origin);

          target.x += direction.x * j;
          target.y += direction.y * j;
          target.z += direction.z * j;

          blockPos.set((int) target.x, (int) target.y, (int) target.z);

          Block currentBlock = worldProvider.getBlock(blockPos);

          if (currentBlock.isDestructible()) {
            if (particleEffects < tunnelActionComponent.maxParticalEffects) {
              EntityBuilder builder = entityManager.newBuilder("engine:smokeExplosion");
              builder.getComponent(LocationComponent.class).setWorldPosition(target);
              builder.build();
              particleEffects++;
            }
            if (random.nextFloat() < tunnelActionComponent.thoroughness) {
              EntityRef blockEntity = blockEntityRegistry.getEntityAt(blockPos);
              blockEntity.send(
                  new DoDamageEvent(
                      tunnelActionComponent.damageAmount, tunnelActionComponent.damageType));
            }

            blockCounter--;
          }

          if (blockCounter <= 0) {
            return;
          }
        }
      }
    }
    // No blocks were destroyed, so cancel the event
    if (blockCounter == tunnelActionComponent.maxDestroyedBlocks) {
      event.consume();
    }
  }
 public void updateTarget() {
   if (!target.exists() && targetBlockPos != null && blockRegistry != null) {
     target = blockRegistry.getEntityAt(targetBlockPos);
   }
 }