@Override
 public void affectCharStats(MOB affected, CharStats affectableStats) {
   super.affectCharStats(affected, affectableStats);
   final int[] breatheables = affectableStats.getBreathables();
   if (breatheables.length == 0) return;
   if ((lastSet != breatheables) || (newSet == null)) {
     newSet =
         Arrays.copyOf(
             affectableStats.getBreathables(), affectableStats.getBreathables().length + 2);
     newSet[newSet.length - 1] = RawMaterial.RESOURCE_SALTWATER;
     newSet[newSet.length - 2] = RawMaterial.RESOURCE_FRESHWATER;
     Arrays.sort(newSet);
     lastSet = breatheables;
   }
   affectableStats.setBreathables(newSet);
 }
Esempio n. 2
0
/*
   Copyright 2000-2010 Bo Zimmerman

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
*/
@SuppressWarnings("unchecked")
public class Mountains extends StdRoom {
  public String ID() {
    return "Mountains";
  }

  public Mountains() {
    super();
    name = "the mountain";
    baseEnvStats.setWeight(5);
    recoverEnvStats();
  }

  public int domainType() {
    return Room.DOMAIN_OUTDOORS_MOUNTAINS;
  }

  public int domainConditions() {
    return Room.CONDITION_NORMAL;
  }

  public static final Integer[] resourceList = {
    Integer.valueOf(RawMaterial.RESOURCE_STONE),
    Integer.valueOf(RawMaterial.RESOURCE_IRON),
    Integer.valueOf(RawMaterial.RESOURCE_LEAD),
    Integer.valueOf(RawMaterial.RESOURCE_SILVER),
    Integer.valueOf(RawMaterial.RESOURCE_COPPER),
    Integer.valueOf(RawMaterial.RESOURCE_TIN),
    Integer.valueOf(RawMaterial.RESOURCE_AMETHYST),
    Integer.valueOf(RawMaterial.RESOURCE_GARNET),
    Integer.valueOf(RawMaterial.RESOURCE_AMBER),
    Integer.valueOf(RawMaterial.RESOURCE_HERBS),
    Integer.valueOf(RawMaterial.RESOURCE_OPAL),
    Integer.valueOf(RawMaterial.RESOURCE_TOPAZ),
    Integer.valueOf(RawMaterial.RESOURCE_BASALT),
    Integer.valueOf(RawMaterial.RESOURCE_SHALE),
    Integer.valueOf(RawMaterial.RESOURCE_PUMICE),
    Integer.valueOf(RawMaterial.RESOURCE_SANDSTONE),
    Integer.valueOf(RawMaterial.RESOURCE_SOAPSTONE),
    Integer.valueOf(RawMaterial.RESOURCE_AQUAMARINE),
    Integer.valueOf(RawMaterial.RESOURCE_CRYSOBERYL),
    Integer.valueOf(RawMaterial.RESOURCE_ONYX),
    Integer.valueOf(RawMaterial.RESOURCE_TURQUIOSE),
    Integer.valueOf(RawMaterial.RESOURCE_DIAMOND),
    Integer.valueOf(RawMaterial.RESOURCE_CRYSTAL),
    Integer.valueOf(RawMaterial.RESOURCE_QUARTZ),
    Integer.valueOf(RawMaterial.RESOURCE_PLATINUM)
  };
  public static final Vector roomResources = new Vector(Arrays.asList(resourceList));

  public Vector resourceChoices() {
    return Mountains.roomResources;
  }
}
  @Override
  public void addItemDeficiency(final String zapperMask) {
    final DoubleFilterer<Item>[] newerArray =
        Arrays.copyOf(this.proficiencies, this.proficiencies.length + 1);
    newerArray[newerArray.length - 1] =
        new DoubleFilterer<Item>() {
          final MaskingLibrary.CompiledZMask mask = CMLib.masking().getPreCompiledMask(zapperMask);

          @Override
          public DoubleFilterer.Result getFilterResult(Item obj) {
            return CMLib.masking().maskCheck(mask, obj, true)
                ? DoubleFilterer.Result.REJECTED
                : DoubleFilterer.Result.NOTAPPLICABLE;
          }
        };
    this.proficiencies = newerArray;
  }
Esempio n. 4
0
  public boolean doArchonDBCompare(MOB mob, String scope, String firstWord, Vector commands)
      throws java.io.IOException {
    CMClass.CMObjectType doType = OBJECT_TYPES.get(firstWord.toUpperCase());
    if (doType == null) doType = OBJECT_TYPES.get(firstWord.toUpperCase() + "S");
    if (doType != null) commands.remove(0);
    else doType = CMClass.CMObjectType.LOCALE;

    final String theRest = CMParms.combineQuoted(commands, 0);
    DBConnector dbConnector = null;
    final String dbClass = CMParms.getParmStr(theRest, "DBCLASS", "");
    final String dbService = CMParms.getParmStr(theRest, "DBSERVICE", "");
    final String dbUser = CMParms.getParmStr(theRest, "DBUSER", "");
    final String dbPass = CMParms.getParmStr(theRest, "DBPASS", "");
    final int dbConns = CMParms.getParmInt(theRest, "DBCONNECTIONS", 3);
    final int dbPingIntMins = CMParms.getParmInt(theRest, "DBPINGINTERVALMINS", 30);
    final boolean dbReuse = CMParms.getParmBool(theRest, "DBREUSE", true);
    final String ignore = CMParms.getParmStr(theRest, "IGNORE", "");
    final String maskStr = CMParms.getParmStr(theRest, "MASK", "");
    final Set<String> ignores = new SHashSet(CMParms.parseCommas(ignore.toUpperCase(), true));
    final MaskingLibrary.CompiledZapperMask mask = CMLib.masking().maskCompile(maskStr);
    if (dbClass.length() == 0) {
      mob.tell(L("This command requires DBCLASS= to be set."));
      return false;
    }
    if (dbService.length() == 0) {
      mob.tell(L("This command requires DBSERVICE= to be set."));
      return false;
    }
    if (dbUser.length() == 0) {
      mob.tell(L("This command requires DBUSER= to be set."));
      return false;
    }
    if (dbPass.length() == 0) {
      mob.tell(L("This command requires DBPASS= to be set."));
      return false;
    }

    dbConnector =
        new DBConnector(
            dbClass, dbService, dbUser, dbPass, dbConns, dbPingIntMins, dbReuse, false, false);
    dbConnector.reconnect();
    final DBInterface dbInterface = new DBInterface(dbConnector, null);

    final DBConnection DBTEST = dbConnector.DBFetch();
    if (DBTEST != null) dbConnector.DBDone(DBTEST);
    mob.tell(L("Loading database rooms..."));
    final List<Room> rooms = new LinkedList<Room>();
    if ((!dbConnector.amIOk()) || (!dbInterface.isConnected())) {
      mob.tell(L("Failed to connect to database."));
      return false;
    }
    if (scope.equalsIgnoreCase("AREA"))
      rooms.addAll(
          Arrays.asList(dbInterface.DBReadRoomObjects(mob.location().getArea().Name(), false)));
    else if (scope.equalsIgnoreCase("ROOM")) {
      final Room R = dbInterface.DBReadRoomObject(mob.location().roomID(), false);
      if (R != null) rooms.add(R);
    } else
      for (final Enumeration<Area> e = CMLib.map().areas(); e.hasMoreElements(); )
        rooms.addAll(Arrays.asList(dbInterface.DBReadRoomObjects(e.nextElement().Name(), false)));
    if (rooms.size() == 0) {
      mob.tell(L("No rooms found."));
      return false;
    }
    for (final Room R : rooms) dbInterface.DBReadContent(R.roomID(), R, false);
    mob.tell(L("Data loaded, starting scan."));
    final Comparator<MOB> convM =
        new Comparator<MOB>() {
          @Override
          public int compare(MOB arg0, MOB arg1) {
            final int x = arg0.ID().compareTo(arg1.ID());
            return (x != 0) ? x : arg0.Name().compareTo(arg1.Name());
          }
        };
    final Comparator<Item> convI =
        new Comparator<Item>() {
          @Override
          public int compare(Item arg0, Item arg1) {
            final int x = arg0.ID().compareTo(arg1.ID());
            return (x != 0) ? x : arg0.Name().compareTo(arg1.Name());
          }
        };
    try {
      for (final Room dbR : rooms) {
        Room R = CMLib.map().getRoom(dbR.roomID());
        if (R == null) {
          if (doType == CMClass.CMObjectType.LOCALE)
            Log.sysOut("Merge", dbR.roomID() + " not in database");
          // import, including exits!
          continue;
        }
        synchronized (("SYNC" + dbR.roomID()).intern()) {
          final Area.State oldFlags = R.getArea().getAreaState();
          R.getArea().setAreaState(Area.State.FROZEN);

          boolean updateMobs = false;
          boolean updateItems = false;
          final boolean updateRoom = false;
          R = CMLib.map().getRoom(R);
          CMLib.map().resetRoom(R);
          final List<MOB> mobSetL = new Vector<MOB>();
          for (final Enumeration<MOB> e = dbR.inhabitants(); e.hasMoreElements(); )
            mobSetL.add(e.nextElement());
          final MOB[] mobSet = mobSetL.toArray(new MOB[0]);
          Arrays.sort(mobSet, convM);
          String lastName = "";
          int ct = 1;
          final HashSet<MOB> doneM = new HashSet<MOB>();
          for (final MOB dbM : mobSet) {
            if (!lastName.equals(dbM.Name())) ct = 1;
            else ct++;
            final String rName = dbM.Name() + "." + ct;
            MOB M = null;
            int ctr = ct;
            for (final Enumeration<MOB> m = R.inhabitants(); m.hasMoreElements(); ) {
              final MOB M1 = m.nextElement();
              if (M1.Name().equalsIgnoreCase(dbM.Name()) && ((--ctr) <= 0)) {
                M = M1;
                break;
              }
            }
            if (M == null) {
              if (amMerging(doType, mask, dbM) && (!ignore.contains("MISSING"))) {
                if (mob.session()
                    .confirm(
                        L(
                            "MOB: @x1.@x2 not in local room.\n\rWould you like to add it (y/N)?",
                            dbR.roomID(),
                            rName),
                        L("N"))) {
                  M = (MOB) dbM.copyOf();
                  M.bringToLife(R, true);
                  doneM.add(M);
                  updateMobs = true;
                  Log.sysOut("Merge", mob.Name() + " added mob " + dbR.roomID() + "." + rName);
                }
              }
            } else {
              doneM.add(M);
              if (amMerging(doType, mask, dbM)) {
                if (!dbM.sameAs(M)) {
                  final MOB oldM = (MOB) M.copyOf();
                  if ((dbMerge(mob, "^MMOB " + dbR.roomID() + "." + rName + "^N", dbM, M, ignores))
                      && (!oldM.sameAs(M))) {
                    Log.sysOut("Merge", mob.Name() + " modified mob " + dbR.roomID() + "." + rName);
                    updateMobs = true;
                  }
                }
              }
              final STreeSet<Item> itemSetL = new STreeSet<Item>(convI);
              for (final Enumeration<Item> e = dbM.items(); e.hasMoreElements(); )
                itemSetL.add(e.nextElement());
              final Item[] itemSet = itemSetL.toArray(new Item[0]);
              Arrays.sort(itemSet, convI);
              String lastIName = "";
              int ict = 1;
              final HashSet<Item> doneI = new HashSet<Item>();
              for (final Item dbI : itemSet) {
                if (!lastIName.equals(dbI.Name())) ict = 1;
                else ict++;
                final String rIName = dbI.Name() + "." + ict;
                Item I = null;
                ctr = ict;
                for (final Enumeration<Item> i = M.items(); i.hasMoreElements(); ) {
                  final Item I1 = i.nextElement();
                  if (I1.Name().equalsIgnoreCase(dbI.Name()) && ((--ctr) <= 0)) {
                    I = I1;
                    break;
                  }
                }
                if (I == null) {
                  if (amMerging(doType, mask, dbI) && (!ignore.contains("MISSING"))) {
                    if (mob.session()
                        .confirm(
                            L(
                                "Item: @x1.@x2.@x3 not in local room.\n\rWould you like to add it (y/N)?",
                                dbR.roomID(),
                                dbM.Name(),
                                rIName),
                            L("N"))) {
                      I = (Item) dbI.copyOf();
                      M.addItem(I);
                      doneI.add(I);
                      final Item cI =
                          (dbI.container() == null) ? null : M.findItem(dbI.container().Name());
                      if (cI instanceof Container) I.setContainer((Container) cI);
                      updateMobs = true;
                      Log.sysOut(
                          "Merge",
                          mob.Name()
                              + " added item "
                              + dbR.roomID()
                              + "."
                              + dbM.Name()
                              + "."
                              + rIName);
                    }
                  }
                } else if (amMerging(doType, mask, dbI)) {
                  doneI.add(I);
                  if (!dbI.sameAs(I)) {
                    final Item oldI = (Item) I.copyOf();
                    if ((dbMerge(
                            mob,
                            "^IITEM ^M" + dbR.roomID() + "." + dbM.Name() + "." + rIName + "^N",
                            dbI,
                            I,
                            ignores))
                        && (!oldI.sameAs(I))) {
                      Log.sysOut(
                          "Merge",
                          mob.Name()
                              + " modified item "
                              + dbR.roomID()
                              + "."
                              + dbM.Name()
                              + "."
                              + rIName);
                      updateMobs = true;
                    }
                  }
                }
                lastIName = dbI.Name();
              }
              for (final Enumeration<Item> i = M.items(); i.hasMoreElements(); ) {
                final Item I = i.nextElement();
                if (amMerging(doType, mask, I)
                    && (!doneI.contains(I))
                    && (!ignore.contains("EXTRA"))) {
                  if (mob.session()
                      .confirm(
                          L(
                              "Item: @x1.@x2.@x3 not in database.\n\rWould you like to delete it (y/N)?",
                              R.roomID(),
                              M.Name(),
                              I.Name()),
                          L("N"))) {
                    M.delItem(I);
                    updateMobs = true;
                    Log.sysOut(
                        "Merge",
                        mob.Name()
                            + " deleted item "
                            + R.roomID()
                            + "."
                            + M.Name()
                            + "."
                            + I.Name());
                  }
                }
              }
            }
            lastName = dbM.Name();
          }
          for (final Enumeration<MOB> r = R.inhabitants(); r.hasMoreElements(); ) {
            final MOB M = r.nextElement();
            if (amMerging(doType, mask, M)
                && (!doneM.contains(M))
                && (M.isMonster())
                && (!ignore.contains("EXTRA"))) {
              if (mob.session()
                  .confirm(
                      L(
                          "MOB: @x1.@x2 not in database.\n\rWould you like to delete it (y/N)?",
                          R.roomID(),
                          M.Name()),
                      L("N"))) {
                R.delInhabitant(M);
                updateMobs = true;
                Log.sysOut("Merge", mob.Name() + " deleted mob " + R.roomID() + "." + M.Name());
              }
            }
          }

          final STreeSet<Item> itemSetL = new STreeSet<Item>(convI);
          for (final Enumeration<Item> e = dbR.items(); e.hasMoreElements(); )
            itemSetL.add(e.nextElement());
          final Item[] itemSet = itemSetL.toArray(new Item[0]);
          Arrays.sort(itemSet, convI);
          lastName = "";
          ct = 1;
          final HashSet<Item> doneI = new HashSet<Item>();
          for (final Item dbI : itemSet) {
            if (!lastName.equals(dbI.Name())) ct = 1;
            else ct++;
            final String rName = dbI.Name() + "." + ct;
            Item I = null;
            int ctr = ct;
            for (final Enumeration<Item> i = R.items(); i.hasMoreElements(); ) {
              final Item I1 = i.nextElement();
              if (I1.Name().equalsIgnoreCase(dbI.Name()) && ((--ctr) <= 0)) {
                I = I1;
                break;
              }
            }
            if (I == null) {
              if (amMerging(doType, mask, dbI) && (!ignore.contains("MISSING"))) {
                if (mob.session()
                    .confirm(
                        L(
                            "Item: @x1.@x2 not in local room.\n\rWould you like to add it (y/N)?",
                            dbR.roomID(),
                            rName),
                        L("N"))) {
                  I = (Item) dbI.copyOf();
                  R.addItem(I);
                  doneI.add(I);
                  final Item cI =
                      (dbI.container() == null) ? null : R.findItem(dbI.container().Name());
                  if (cI instanceof Container) I.setContainer((Container) cI);
                  updateItems = true;
                  Log.sysOut("Merge", mob.Name() + " added item " + dbR.roomID() + "." + rName);
                }
              }
            } else if (amMerging(doType, mask, dbI)) {
              doneI.add(I);
              if (!dbI.sameAs(I)) {
                final Item oldI = (Item) I.copyOf();
                if ((dbMerge(mob, "^IITEM " + dbR.roomID() + "." + rName + "^N", dbI, I, ignores))
                    && (!oldI.sameAs(I))) {
                  Log.sysOut("Merge", mob.Name() + " modified item " + dbR.roomID() + "." + rName);
                  updateItems = true;
                }
              }
            }
            lastName = dbI.Name();
          }
          for (final Enumeration<Item> i = R.items(); i.hasMoreElements(); ) {
            final Item I = i.nextElement();
            if (amMerging(doType, mask, I) && (!doneI.contains(I)) && (!ignore.contains("EXTRA"))) {
              if (mob.session()
                  .confirm(
                      L(
                          "Item: @x1.@x2 not in database.\n\rWould you like to delete it (y/N)?",
                          R.roomID(),
                          I.Name()),
                      L("N"))) {
                R.delItem(I);
                updateItems = true;
                Log.sysOut("Merge", mob.Name() + " deleted item " + R.roomID() + "." + I.Name());
              }
            }
          }
          if (updateRoom) CMLib.database().DBUpdateRoom(R);
          if (updateItems) CMLib.database().DBUpdateItems(R);
          if (updateMobs) CMLib.database().DBUpdateMOBs(R);
          CMLib.map().resetRoom(R);
          R.getArea().setAreaState(oldFlags);
        }
        dbR.destroy();
      }
      mob.tell(L("Done"));
    } catch (final CMException cme) {
      mob.tell(L("Cancelled."));
    }
    dbInterface.shutdown();
    return true;
  }
 @Override
 public Collection<CharClass> getCharClasses() {
   return Arrays.asList(myClasses);
 }
Esempio n. 6
0
/*
   Copyright 2003-2015 Bo Zimmerman

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

	   http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
*/
public class Swamp extends StdRoom implements Drink {
  @Override
  public String ID() {
    return "Swamp";
  }

  public Swamp() {
    super();
    name = "the swamp";
    basePhyStats.setWeight(3);
    recoverPhyStats();
    climask = Places.CLIMASK_WET;
  }

  @Override
  public int domainType() {
    return Room.DOMAIN_OUTDOORS_SWAMP;
  }

  @Override
  public void executeMsg(final Environmental myHost, final CMMsg msg) {
    if ((msg.amITarget(this)
            || (msg.targetMinor() == CMMsg.TYP_ADVANCE)
            || (msg.targetMinor() == CMMsg.TYP_RETREAT))
        && (!msg.source().isMonster())
        && (msg.source().curState().getHitPoints() < msg.source().maxState().getHitPoints())
        && (CMLib.dice().rollPercentage() == 1)
        && (CMLib.dice().rollPercentage() == 1)
        && (!CMSecurity.isDisabled(CMSecurity.DisFlag.AUTODISEASE))) {
      Ability A = null;
      if (CMLib.dice().rollPercentage() > 50) A = CMClass.getAbility("Disease_Chlamydia");
      else A = CMClass.getAbility("Disease_Malaria");
      if ((A != null) && (msg.source().fetchEffect(A.ID()) == null))
        A.invoke(msg.source(), msg.source(), true, 0);
    }
    if (msg.amITarget(this) && (msg.targetMinor() == CMMsg.TYP_DRINK)) {
      final MOB mob = msg.source();
      final boolean thirsty = mob.curState().getThirst() <= 0;
      final boolean full =
          !mob.curState().adjThirst(thirstQuenched(), mob.maxState().maxThirst(mob.baseWeight()));
      if (thirsty) mob.tell(L("You are no longer thirsty."));
      else if (full) mob.tell(L("You have drunk all you can."));
      if (CMLib.dice().rollPercentage() < 10) {
        Ability A = CMClass.getAbility("Disease_Malaria");
        if ((A != null) && (msg.source().fetchEffect(A.ID()) == null))
          A.invoke(msg.source(), msg.source(), true, 0);
      }
    }
    super.executeMsg(myHost, msg);
  }

  public static final Integer[] resourceList = {
    Integer.valueOf(RawMaterial.RESOURCE_JADE),
    Integer.valueOf(RawMaterial.RESOURCE_SCALES),
    Integer.valueOf(RawMaterial.RESOURCE_COCOA),
    Integer.valueOf(RawMaterial.RESOURCE_COAL),
    Integer.valueOf(RawMaterial.RESOURCE_PIPEWEED),
    Integer.valueOf(RawMaterial.RESOURCE_BAMBOO),
    Integer.valueOf(RawMaterial.RESOURCE_REED),
    Integer.valueOf(RawMaterial.RESOURCE_SUGAR),
    Integer.valueOf(RawMaterial.RESOURCE_CLAY),
  };

  @Override
  protected int baseThirst() {
    return 0;
  }

  @Override
  public long decayTime() {
    return 0;
  }

  @Override
  public void setDecayTime(long time) {}

  @Override
  public int thirstQuenched() {
    return 500;
  }

  @Override
  public int liquidHeld() {
    return Integer.MAX_VALUE - 1000;
  }

  @Override
  public int liquidRemaining() {
    return Integer.MAX_VALUE - 1000;
  }

  @Override
  public int liquidType() {
    return RawMaterial.RESOURCE_FRESHWATER;
  }

  @Override
  public void setLiquidType(int newLiquidType) {}

  @Override
  public void setThirstQuenched(int amount) {}

  @Override
  public void setLiquidHeld(int amount) {}

  @Override
  public void setLiquidRemaining(int amount) {}

  @Override
  public boolean disappearsAfterDrinking() {
    return false;
  }

  @Override
  public boolean containsDrink() {
    return true;
  }

  @Override
  public int amountTakenToFillMe(Drink theSource) {
    return 0;
  }

  public static final List<Integer> roomResources =
      new Vector<Integer>(Arrays.asList(resourceList));

  @Override
  public List<Integer> resourceChoices() {
    return Swamp.roomResources;
  }
}