private void handleTarget(Player player, HumanNPC npc, Guard guard) { if (!guard.isAggressive()) { return; } FlagList flags = guard.getFlags(); flags.processEntities(npc, player.getLocation(), getNearby(player, guard)); if (flags.getResult() != null) { guard.target(flags.getResult(), npc); } }
public static void run(RobotController _rc) throws Exception { switch (_rc.getType()) { case ARCHON: Archon.run(_rc); break; case GUARD: Guard.run(_rc); break; case SCOUT: Scout.run(_rc); break; case SOLDIER: Soldier.run(_rc); break; case TTM: case TURRET: Turret.run(_rc); break; case VIPER: Viper.run(_rc); break; default: // this shouldn't happen throw new Exception("I am a bad robot."); } }
public Object evaluateGuard() { if (guard == null) { return Boolean.TRUE; } else { return guard.evaluate(); } }
public List<Guard> getGuards() throws Exception { List<Guard> rv = new ArrayList<Guard>(); Class.forName("org.hsqldb.jdbcDriver"); Connection conn = DriverManager.getConnection("jdbc:hsqldb:/home/hsqldb/testdb", "sa", ""); Statement s = conn.createStatement(); ResultSet rs = s.executeQuery("SELECT id, name, age FROM guard"); while (rs.next()) { Guard g = new Guard(); g.setId(rs.getInt(1)); g.setName(rs.getString(2)); g.setAge(rs.getInt(3)); rv.add(g); } return rv; }
/** * If specimen is null, returns null. Otherwise passes it to my wrapped Guard, if there is one. */ public Object coerce(Object specimen, OneArgFunc optEjector) { // shorten first specimen = Ref.resolution(specimen); if (null == specimen) { return null; } else if (null == myOptSubGuard) { throw Thrower.toEject(optEjector, "must be null"); } else { return myOptSubGuard.coerce(specimen, optEjector); } }
/** Checks the guard (if there is one) before performing a default serialization. */ @DSGenerator( tool_name = "Doppelganger", tool_version = "2.0", generated_on = "2014-08-13 13:14:14.534 -0400", hash_original_method = "348630D7F52CD6FE922772D18E5A4EE3", hash_generated_method = "2981E8416B8EEBBC7C8DB8E201224C05") private void writeObject(java.io.ObjectOutputStream out) throws IOException { if (guard != null) { guard.checkGuard(object); } out.defaultWriteObject(); }
/** * Returns the guarded {@code Object} if the associated {@code Guard} permits access. If access is * not granted, then a {@code SecurityException} is thrown. * * @return the guarded object. * @exception SecurityException if access is not granted to the guarded object. */ @DSGenerator( tool_name = "Doppelganger", tool_version = "2.0", generated_on = "2014-08-13 13:14:14.532 -0400", hash_original_method = "3EF173A6C6367EC6BC9E6B537A363AF5", hash_generated_method = "7C5E9C80A577D6664DDEDA5993E62201") public Object getObject() throws SecurityException { if (guard != null) { guard.checkGuard(object); } return object; }
public boolean checkGuardCondition(String con, Variable v, Guard g) { if (con.equals("=")) { if (v.getVarValue() == g.getConditionValue()) { return true; } } else if (con.contains("<=")) { System.out.println("Reached" + con); if (v.getVarValue().intValue() <= g.getConditionValue().intValue()) { System.out.println("Evaluated" + con); return true; } } else if (con.equals(">=")) { System.out.println("Reached" + con); if (v.getVarValue().intValue() >= g.getConditionValue().intValue()) { System.out.println("Evaluated" + con); return true; } } else if (con.equals("!=")) { System.out.println("Reached" + con); if (v.getVarValue().intValue() != g.getConditionValue().intValue()) { System.out.println("Evaluated" + con); return true; } } else if (con.equals("<")) { System.out.println("Reached" + con); if (v.getVarValue().intValue() < g.getConditionValue().intValue()) { System.out.println("Evaluated" + con); return true; } } else if (con.equals(">")) { System.out.println("Reached" + con); if (v.getVarValue().intValue() > g.getConditionValue().intValue()) { System.out.println("Evaluated" + con); return true; } } else { return false; } return false; }
public void generate(String inputFileName) throws Exception { List<MetaClass> metaClasses = new ArrayList<>(); List<LifeLine> lifeLines = new ArrayList<>(); List<MethodInvocation> rootMessages = new ArrayList<>(); MethodInvocation parentMessage = new MethodInvocation(); GsonBuilder builder = new GsonBuilder(); List<MethodInvocation> methodInvocations = new ArrayList<>(); Package mainPackage = new Package(); List<Guard> listOfGuards = new ArrayList<>(); Map<Guard, Instruction> guardToCFMap = new HashMap<>(); List<Instruction> combinedFragments = new ArrayList<Instruction>(); List<Operation> operationsList = new ArrayList<>(); builder.registerTypeAdapter(RefObject.class, new RefObjectJsonDeSerializer()); Gson gson = builder.create(); Element myTypes = gson.fromJson(new FileReader(inputFileName), Element.class); if (myTypes._type.equals("Project")) { List<Element> umlElements = myTypes .ownedElements .stream() .filter(f -> f._type.equals("UMLModel")) .collect(Collectors.toList()); if (umlElements.size() > 0) { // There has be to atleast one UMLModel package Element element = umlElements.get(0); // package that the classes are supposed to be in mainPackage.setName(element.name); List<Element> umlPackages = element .ownedElements .stream() .filter(g -> g._type.equals("UMLPackage")) .collect(Collectors.toList()); if (umlPackages.size() > 1) { // There has to be two packages- one for class one for behaviour Element classes = umlPackages.get(0); Element behaviour = umlPackages.get(1); // *--------------------------CLASSES-------------------------------*// // in the first pass, get all classes that are defined in the diagram // get details that can be directly inferred from the json like, fields and operations, // which do not refer to other classes for (Element umlClass : classes.getOwnedElements()) { MetaClass metaClass = new MetaClass(umlClass.name, umlClass._id); // check if class is interface or not because there is no distinction in json if (umlClass._type.equals("UMLClass")) { metaClass.setInterface(false); } else { metaClass.setInterface(true); } if (umlClass.operations != null) { metaClass.setOperations(umlClass.operations); operationsList.addAll(metaClass.operations); } if (umlClass.attributes != null) { metaClass.setFields(umlClass.attributes); } metaClasses.add(metaClass); } // in second pass, define associations and generalizations for these classes for (Element umlClass : classes.getOwnedElements()) { if (umlClass.ownedElements != null) { // find corresponding metaclass, then populate the secondary inferences List<MetaClass> correspondingMetaClassList = metaClasses .stream() .filter(f -> f._id.equals(umlClass._id)) .collect(Collectors.toList()); MetaClass correspondingMetaClass = correspondingMetaClassList.get(0); List<Element> umlAssociations = umlClass .ownedElements .stream() .filter(f -> f._type.equals("UMLAssociation")) .collect(Collectors.toList()); if (umlAssociations.size() > 0) { correspondingMetaClass.setAssociations(metaClasses, umlAssociations); } List<Element> umlGeneralization = umlClass .ownedElements .stream() .filter(f -> f._type.equals("UMLGeneralization")) .collect(Collectors.toList()); if (umlGeneralization.size() > 0) { correspondingMetaClass.setGeneralizations(metaClasses, umlGeneralization); } List<Element> umlRealization = umlClass .ownedElements .stream() .filter(f -> f._type.equals("UMLInterfaceRealization")) .collect(Collectors.toList()); if (umlRealization.size() > 0) { correspondingMetaClass.setInterfaceRealization(metaClasses, umlRealization); } } } // *--------------------------CLASSES-------------------------------*// // *----------------------- BEHAVIOUR---------------------------------*// for (Element umlCollaboration : behaviour.getOwnedElements()) { // Role to Class mapping ArrayList<Element> attributes = umlCollaboration.attributes; HashMap<String, MetaClass> roleToClassMap = new HashMap<>(); if (attributes != null) { for (Element attribute : attributes) { List<MetaClass> roleClass = metaClasses .stream() .filter(f -> f._id.equals(attribute.type.$ref)) .collect(Collectors.toList()); roleToClassMap.put(attribute._id, roleClass.get(0)); } } for (Element umlInteraction : umlCollaboration.ownedElements) { // mapping lifelines to the classes they correspond ArrayList<Element> participants = umlInteraction.participants; if (participants != null && participants.size() > 0) { for (Element participant : participants) { MetaClass participantClass = roleToClassMap.get(participant.represent.$ref); LifeLine lifeLine = new LifeLine(); lifeLine.setName(participant.name); lifeLine.setId(participant._id); lifeLine.setMetaClass(participantClass); lifeLines.add(lifeLine); } } // first parse all the combined fragments and get ready if (umlInteraction.fragments != null) { for (Element fragment : umlInteraction.fragments) { // depending on the fragment set the class Instruction instruction = null; if (fragment.interactionOperator.equals("loop")) { Loop loop = new Loop(); loop.setId(fragment._id); loop.setWeight(0); Guard guard = new Guard(fragment.operands.get(0)._id); // loop can have only one condition--- one condition-- condition is made up of // AND or OR's guard.setCondition(fragment.operands.get(0).guard); loop.setGuard(guard); instruction = loop; combinedFragments.add(loop); listOfGuards.add(guard); guardToCFMap.put(guard, loop); } if (fragment.interactionOperator.equals("alt")) { Conditional c = new Conditional(); c.setId(fragment._id); c.setWeight(0); instruction = c; combinedFragments.add(c); Guard consequence = new Guard(fragment.operands.get(0)._id); consequence.setCondition(fragment.operands.get(0).guard); c.setCons(consequence); listOfGuards.add(consequence); guardToCFMap.put(consequence, c); consequence.setConsequence(true); if (fragment.operands.size() > 1) { Guard alternate = new Guard(fragment.operands.get(1)._id); alternate.setCondition(fragment.operands.get(1).guard); c.setAlt(alternate); listOfGuards.add(alternate); guardToCFMap.put(alternate, c); alternate.setAlternative(true); } } if (fragment.tags != null) { for (Element tag : fragment.tags) { if (tag.name.equals("parent")) { List<Instruction> instructionList = combinedFragments .stream() .filter(e -> e.getId().equals(tag.reference.$ref)) .collect(Collectors.toList()); if (instructionList.size() > 0) { instructionList.get(0).getBlock().add(instruction); instruction.setParent(instructionList.get(0)); } } } } } } // parsing the messages and make nodes out them to later build a tree from the // lifelines ArrayList<Element> messages = umlInteraction.messages; Element startMessage = messages.get(0); String sourceRef = startMessage.source.$ref; String targetRef = startMessage.target.$ref; Element endMessage = null; LifeLine sourceLifeLine = getLifeLine(lifeLines, sourceRef); LifeLine targetLifeLine = getLifeLine(lifeLines, targetRef); // First message processing parentMessage = new MethodInvocation(); parentMessage.setAssignmentTarget(startMessage.assignmentTarget); parentMessage.setMessageSort(startMessage.messageSort); parentMessage.setSource(sourceLifeLine.getMetaClass()); parentMessage.setTarget(targetLifeLine.getMetaClass()); parentMessage.setName(startMessage.name); parentMessage.setId(startMessage._id); if (sourceLifeLine.getId().equals(targetLifeLine.getId())) { parentMessage.setCallerObject("this"); } else { parentMessage.setCallerObject(targetLifeLine.getName()); } int weight = 0; parentMessage.setWeight(weight++); if (startMessage.signature != null) { parentMessage.setSignature(startMessage.signature.$ref); } if (startMessage.tags != null) { for (Element tag : startMessage.tags) { // if (tag.name.equals("CF")) { // parentMessage.setInCF(true); // // parentMessage.setCfID(tag.reference.$ref); // } if (tag.name.equals("operand")) { parentMessage.setOperandId(tag.reference.$ref); } } } MethodInvocation rootMessage = parentMessage; methodInvocations.add(rootMessage); rootMessages.add(rootMessage); Iterator<Element> iter = messages.iterator(); while (iter.hasNext()) { if (iter.next() == endMessage) { continue; } iter.remove(); List<Element> childMessages = getChildMessages(messages, targetRef); for (Element child : childMessages) { LifeLine childSource = getLifeLine(lifeLines, child.source.$ref); LifeLine childTarget = getLifeLine(lifeLines, child.target.$ref); MethodInvocation childMessage = new MethodInvocation(); childMessage.setMessageSort(child.messageSort); childMessage.setSource(childSource.getMetaClass()); childMessage.setTarget(childTarget.getMetaClass()); childMessage.setAssignmentTarget(child.assignmentTarget); childMessage.setName(child.name); childMessage.setId(child._id); childMessage.setWeight(weight++); childMessage.setArguments(child.arguments); if (childSource.getId().equals(childTarget.getId())) { childMessage.setCallerObject("this"); } else { childMessage.setCallerObject(childTarget.getName()); } if (child.signature != null) { childMessage.setSignature(child.signature.$ref); } if (child.tags != null) { for (Element tag : child.tags) { // if (tag.name.equals("CF")) { // childMessage.setInCF(true); // // childMessage.setCfID(tag.reference.$ref); // } if (tag.name.equals("operand")) { childMessage.setOperandId(tag.reference.$ref); } } } parentMessage.childNodes.add(childMessage); methodInvocations.add(childMessage); } if (childMessages.size() > 0) { List<MethodInvocation> nextMessage = parentMessage .childNodes .stream() .filter(f -> !f.source.equals(f.target)) .collect(Collectors.toList()); List<Element> startMessageNext = childMessages .stream() .filter(f -> !f.source.$ref.equals(f.target.$ref)) .collect(Collectors.toList()); startMessage = startMessageNext.get(0); targetRef = startMessage.target.$ref; sourceRef = startMessage.source.$ref; parentMessage = nextMessage.get(0); if (childMessages.size() > 1) { endMessage = childMessages.get(childMessages.size() - 1); } } } } for (MethodInvocation methodInvocation : methodInvocations) { List<Operation> matchingOperation = operationsList .stream() .filter(f -> f._id.equals(methodInvocation.getSignature())) .collect(Collectors.toList()); if (matchingOperation.size() > 0) { operationMap.put(methodInvocation, matchingOperation.get(0)._id); methodInvocation.setOperation(matchingOperation.get(0)); } } Stack stack = new Stack(); for (MethodInvocation root : methodInvocations) { stack.push(root); while (!stack.empty()) { MethodInvocation methodInvocation = (MethodInvocation) stack.pop(); Operation currentOperation = methodInvocation.getOperation(); if (currentOperation != null) { // all child nodes of this node make up its body List<MethodInvocation> childNodes = methodInvocation.childNodes; for (MethodInvocation child : childNodes) { stack.push(child); } for (MethodInvocation childNode : childNodes) { if (childNode.getOperandId() != null) { List<Instruction> combinedFragmentsList = combinedFragments .stream() .filter(f -> f.getId().equals(childNode.getCfID())) .collect(Collectors.toList()); List<Guard> guardList = listOfGuards .stream() .filter(f -> f.id.equals(childNode.getOperandId())) .collect(Collectors.toList()); if (guardList.size() > 0) { Guard currentGuard = guardList.get(0); Instruction instruction = guardToCFMap.get(guardList.get(0)); // get the topmost CF if it is in a tree Instruction parent = instruction.getParent(); while (instruction.getParent() != null) { instruction = instruction.getParent(); } if (currentGuard.isConsequence) { Conditional conditional = (Conditional) instruction; if (!conditional.getConsequence().contains(childNode)) { conditional.getConsequence().add(childNode); } } if (currentGuard.isAlternative) { Conditional conditional = (Conditional) instruction; if (!conditional.getAlternative().contains(childNode)) { conditional.getAlternative().add(childNode); } } if (!currentGuard.isAlternative && !currentGuard.isConsequence) { Loop loop = (Loop) instruction; loop.getBlock().add(childNode); } else { if (!currentOperation.getBlock().contains(instruction)) { currentOperation.getBlock().add(instruction); } } } } else { if (!currentOperation.getBlock().contains(childNode)) { currentOperation.getBlock().add(childNode); } } } } } } } } } } // //// printAllData(metaClasses); // while (parentMessage.childNodes != null || parentMessage.childNodes.size() > 0) { // System.out.println("parent " + parentMessage.name); // for (com.cbpro.main.MethodInvocation child : parentMessage.childNodes) { // System.out.println("child " + child.name); // } // if (parentMessage.childNodes.size() > 0) { // parentMessage = parentMessage.childNodes.get(0); // } else { // break; // } // } mainPackage.print(); File dir = new File("/home/ramyashenoy/Desktop/DemoFolder/" + mainPackage.getName()); boolean successful = dir.mkdir(); if (successful) { System.out.println("directory was created successfully"); for (MetaClass metaClass : metaClasses) { if (metaClass.name.equals("Main")) { continue; } else { String data = metaClass.print(); BufferedWriter out = null; try { FileWriter fstream = new FileWriter( dir.getPath() + "/" + metaClass.name + ".java", true); // true tells to append data. out = new BufferedWriter(fstream); out.write(data); } catch (IOException e) { System.err.println("Error: " + e.getMessage()); } finally { if (out != null) { out.close(); } } } } } else { // creating the directory failed System.out.println("failed trying to create the directory"); } mainPackage.setClasses(metaClasses); }
@Override public void run() { for (HumanNPC npc : CitizensManager.getList().values()) { if (npc.isType("guard")) { Guard guard = npc.getType("guard"); if (guard.isAttacking()) { boolean cancel = false; if (!npc.getHandle().hasTarget() || !guard.isAggressive()) { cancel = true; } else if (npc.getHandle().hasTarget() && !LocationUtils.withinRange( npc.getBaseLocation(), npc.getHandle().getTarget().getLocation(), guard.getProtectionRadius())) { cancel = true; } else if (npc.getHandle().hasTarget() && guard.isBodyguard() && Bukkit.getServer().getPlayer(npc.getOwner()) != null) { Player player = Bukkit.getServer().getPlayer(npc.getOwner()); if (npc.getHandle().getTarget() != player && !LocationUtils.withinRange( npc.getBaseLocation(), player.getLocation(), guard.getProtectionRadius())) { cancel = true; } } if (cancel) { npc.getHandle().cancelTarget(); GuardManager.returnToBase(guard, npc); guard.setAttacking(false); } } if (LocationUtils.withinRange(npc.getLocation(), npc.getBaseLocation(), 3.5)) { if (guard.isReturning()) { guard.setReturning(false); } if (!guard.isAttacking() && npc.isPaused()) { npc.setPaused(false); } } else if (guard.isReturning() && npc.getHandle().getStationaryTicks() > SettingsManager.getInt("MaxStationaryReturnTicks")) { npc.teleport(npc.getBaseLocation()); guard.setReturning(false); } if (guard.isAttacking() || guard.isReturning()) { continue; } if (guard.isBouncer()) { handleTarget(npc.getPlayer(), npc, guard); } else if (guard.isBodyguard()) { if (!npc.isPaused()) { npc.setPaused(true); } Player p = Bukkit.getServer().getPlayer(npc.getOwner()); if (p != null) { handleTarget(p, npc, guard); if (LocationUtils.withinRange( npc.getLocation(), p.getLocation(), guard.getProtectionRadius())) { PathUtils.target(npc, p, false, -1, -1, 25); } else { npc.teleport(p.getLocation()); } } else { if (CitizensManager.getNPC(npc.getUID()) != null) { toRespawn.put( npc.getOwner(), new NPCLocation(npc.getLocation(), npc.getUID(), npc.getOwner())); NPCManager.despawn(npc.getUID(), NPCRemoveReason.DEATH); } } } } } }
private List<Entity> getNearby(Player player, Guard guard) { return player.getNearbyEntities( guard.getHalvedProtectionRadius(), guard.getProtectionRadius(), guard.getHalvedProtectionRadius()); }
public Result evaluate(FSM fsm, Input in) { return guard.evaluate(fsm, in).complement(); }