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();
}
