package com.planet_ink.coffee_mud.Libraries.layouts; import java.util.Enumeration; import java.util.HashSet; import java.util.Hashtable; import java.util.Iterator; import java.util.Map; import java.util.Set; import com.planet_ink.coffee_mud.Libraries.interfaces.AreaGenerationLibrary.LayoutFlags; import com.planet_ink.coffee_mud.Libraries.interfaces.AreaGenerationLibrary.LayoutNode; import com.planet_ink.coffee_mud.Libraries.interfaces.AreaGenerationLibrary.LayoutRuns; import com.planet_ink.coffee_mud.Libraries.interfaces.AreaGenerationLibrary.LayoutTags; import com.planet_ink.coffee_mud.Libraries.interfaces.AreaGenerationLibrary.LayoutTypes; import com.planet_ink.coffee_mud.Locales.interfaces.Room; import com.planet_ink.coffee_mud.core.Directions; import com.planet_ink.coffee_mud.core.collections.SHashtable; /* Copyright 2008-2016 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 DefaultLayoutNode implements LayoutNode { public long[] coord; public Room associatedRoom = null; public Map<Integer, LayoutNode> links = new SHashtable<Integer, LayoutNode>(); private final Map<LayoutTags, String> tags = new SHashtable<LayoutTags, String>(); private final Set<LayoutFlags> flags = new HashSet<LayoutFlags>(); public DefaultLayoutNode(long[] coord) { this.coord = coord; } public DefaultLayoutNode(long x, long y) { this.coord = new long[]{x,y}; } @Override public Room room() { return associatedRoom; } @Override public void setRoom(Room room) { associatedRoom = room; } @Override public long[] coord() { return coord; } @Override public Map<LayoutTags, String> tags() { return tags; } @Override public Map<Integer, LayoutNode> links() { return links; } @Override public void crossLink(LayoutNode to) { links.put(Integer.valueOf(AbstractLayout.getDirection(this, to)), to); to.links().put(Integer.valueOf(AbstractLayout.getDirection(to, this)), this); } @Override public boolean isFlagged(LayoutFlags flag) { return flags.contains(flag); } @Override public LayoutRuns getFlagRuns() { if (tags.containsKey(LayoutTags.NODERUN)) return LayoutRuns.valueOf(tags.get(LayoutTags.NODERUN)); return null; } @Override public void delLink(LayoutNode linkNode) { for (final Iterator<Integer> e = links.keySet().iterator(); e.hasNext();) { final Integer key = e.next(); if (links.get(key) == linkNode) links.remove(key); } } @Override public LayoutNode getLink(int d) { return links.get(Integer.valueOf(d)); } @Override public boolean isStreetLike() { if (links.size() != 2) return false; final Iterator<LayoutNode> linksE = links.values().iterator(); final LayoutNode n1 = linksE.next(); final LayoutNode n2 = linksE.next(); final int d1 = AbstractLayout.getDirection(this, n1); final int d2 = AbstractLayout.getDirection(this, n2); switch (d1) { case Directions.NORTH: return d2 == Directions.SOUTH; case Directions.SOUTH: return d2 == Directions.NORTH; case Directions.EAST: return d2 == Directions.WEST; case Directions.WEST: return d2 == Directions.EAST; } return false; } @Override public void deLink() { for (final Iterator<Integer> e = links.keySet().iterator(); e.hasNext();) { final Integer key = e.next(); final LayoutNode linkNode = links.get(key); linkNode.delLink(this); } links.clear(); } @Override public String toString() { String s = "(" + coord[0] + "," + coord[1] + ") ->"; for (final LayoutNode n : links.values()) s += "(" + n.coord()[0] + "," + n.coord()[1] + "), "; return s; } @Override public void flag(LayoutFlags flag) { final String s = tags.get(LayoutTags.NODEFLAGS); flags.add(flag); if (s == null) tags.put(LayoutTags.NODEFLAGS, "," + flag.toString() + ","); else if (s.indexOf("," + flag.toString() + ",") < 0) tags.put(LayoutTags.NODEFLAGS, s + flag.toString() + ","); } @Override public void flagRun(LayoutRuns run) { tags.put(LayoutTags.NODERUN, run.toString()); } @Override public LayoutTypes type() { return LayoutTypes.valueOf(tags.get(LayoutTags.NODETYPE)); } @Override public void setExits(int[] dirs) { final StringBuffer buf = new StringBuffer(","); for (int d = 0; d < Directions.NUM_DIRECTIONS(); d++) { for (final int dir : dirs) { if (dir == d) { buf.append(Directions.getDirectionChar(d).toLowerCase()).append(","); } } } tags.put(LayoutTags.NODEEXITS, buf.toString()); } @Override public void reType(LayoutTypes type) { tags.put(LayoutTags.NODETYPE, type.toString()); } @Override public String getColorRepresentation(char roomChar, int line) { switch (line) { case 0: if (links.containsKey(Integer.valueOf(Directions.NORTH))) return " ^ "; return " "; case 1: { if (links.containsKey(Integer.valueOf(Directions.EAST))) { if (links.containsKey(Integer.valueOf(Directions.WEST))) return "<" + roomChar + ">"; return " " + roomChar + ">"; } else if (links.containsKey(Integer.valueOf(Directions.WEST))) return "<" + roomChar + " "; return " " + roomChar + " "; } case 2: if (links.containsKey(Integer.valueOf(Directions.SOUTH))) return " v "; return " "; default: return " "; } } }