private void addNode(TableInfo table, Rules rules) {
String tableName = table.table;
List<Map> properties = new ArrayList<>();
Map node =
map(
"filename", tableName,
"labels", asList(rules.labelsFor(table)),
"properties", properties);
for (String field : table.pk) {
properties.add(createJdbcMetaDataProperty(table, rules, field, true));
}
for (String field : table.fields) {
if (!rules.skipPrimaryKey(tableName, field) && table.pk.contains(field)) continue;
properties.add(createJdbcMetaDataProperty(table, rules, field, false));
}
for (Map.Entry<List<String>, String> entry : table.fks.entrySet()) {
List<String> fields = entry.getKey();
String target = entry.getValue();
// todo do we really have to add them as properties in neo?
for (String field : fields) {
properties.add(createJdbcMetaDataProperty(table, rules, field, false));
addRelationship(tableName, target, field, rules);
}
}
nodes.add(node);
}
public void nextStep() {
synchronized (this) {
if (needRecalc) {
recalcImpact();
needRecalc = false;
}
for (iter.x = 0; iter.x < mSize; ++iter.x) {
for (iter.y = 0; iter.y < nSize; ++iter.y) {
final double imp = impMat[iter.x][iter.y];
if (rules.dieCond(imp)) {
fldNew[iter.x][iter.y] = DEAD;
} else if (rules.birthCond(imp)) {
fldNew[iter.x][iter.y] = ALIVE;
}
}
}
swap();
needRecalc = true;
recalcImpact();
}
setChanged();
notifyObservers(new FieldUpdate(this));
}
public List<TemplateRule> getTemplateRules() {
templateRules = new ArrayList<TemplateRule>();
Rules rules = concept.getRules();
List<JAXBElement<? extends AbstractRule>> abstractRules = rules.getAbstractRule();
for (JAXBElement<? extends AbstractRule> jAXBElementRule : abstractRules) {
TemplateRule templateRule = (TemplateRule) jAXBElementRule.getValue();
templateRules.add(templateRule);
}
return templateRules;
}
@Override
@Transactional
public Rules create(Rules toCreate) {
Rules current = getDbRules();
if (current != null
&& !VersionUtil.getRulesVersionCompatibility(current.getVersion(), toCreate.getVersion())) {
return current;
}
return super.create(toCreate);
}
public MVDConstraint(ConceptRoot conceptRoot, Concept concept, ConceptTemplate conceptTemplate) {
this.conceptRoot = conceptRoot;
this.concept = concept;
this.conceptTemplate = conceptTemplate;
List<AttributeRule> attributeRuleList = new ArrayList<AttributeRule>();
Rules rules = conceptTemplate.getRules();
List<JAXBElement<? extends AbstractRule>> abstractRules = rules.getAbstractRule();
for (JAXBElement<? extends AbstractRule> jAXBElementRule : abstractRules) {
AttributeRule attributeRule = (AttributeRule) jAXBElementRule.getValue();
attributeRuleList.add(attributeRule);
}
this.attributeRules = attributeRuleList;
}
public void updateDbRules() {
Rules dbRules = getDbRules();
// Load rules from RPM, we need to know it's version before we know which
// rules to use:
Rules rpmRules = rulesFromFile(getDefaultRulesFile());
log.debug("RPM Rules version: " + rpmRules.getVersion());
if (dbRules == null
|| !VersionUtil.getRulesVersionCompatibility(rpmRules.getVersion(), dbRules.getVersion())) {
this.resetToRpmRules();
}
}
private static Rule<View> getIpAddressRule(Field field, View view, IpAddress ipAddress) {
if (!TextView.class.isAssignableFrom(view.getClass())) {
Log.w(TAG, String.format(WARN_TEXT, field.getName(), IpAddress.class.getSimpleName()));
return null;
}
int messageResId = ipAddress.messageResId();
String message =
messageResId != 0 ? view.getContext().getString(messageResId) : ipAddress.message();
return Rules.or(
message,
Rules.eq(null, Rules.EMPTY_STRING),
Rules.regex(message, Rules.REGEX_IP_ADDRESS, true));
}
private Map createRelationshipNode(String tableName, String field, Rules rules) {
return map(
"fileKey", field,
"neoKey", field,
"filename", tableName,
"label", rules.labelFor(tableName));
}
private List<MethodRule> getRulesAnnotation(Class<?> clazz) {
List<Rules> annotations = reflectionUtil.findAllInherited(clazz, Rules.class);
List<MethodRule> rules = new ArrayList<MethodRule>();
for (Rules annotation : annotations) {
for (Class<? extends MethodRule> c : annotation.value()) {
try {
rules.add(c.newInstance());
} catch (InstantiationException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
}
return rules;
}
public Map<String, Object> add(TableInfo table, Rules rules) {
if (rules.isNode(table)) {
addNode(table, rules);
} else {
addRelationship(table, rules);
}
return map("nodes", nodes, "relationships", relationships);
}
private void addRelationship(String tableName, String target, String field, Rules rules) {
Map rel =
map(
"filename", tableName,
"name", rules.relTypeFor(field),
"from", createRelationshipNode(tableName, field, rules),
"to", createRelationshipNode(target, field, rules));
relationships.add(rel);
}
private final Bullet setFireImpl(double power) {
if (Double.isNaN(power)) {
println("SYSTEM: You cannot call fire(NaN)");
return null;
}
if (getGunHeatImpl() > 0 || getEnergyImpl() == 0) {
return null;
}
power = min(getEnergyImpl(), min(max(power, Rules.MIN_BULLET_POWER), Rules.MAX_BULLET_POWER));
Bullet bullet;
BulletCommand wrapper;
Event currentTopEvent = eventManager.getCurrentTopEvent();
nextBulletId++;
if (currentTopEvent != null
&& currentTopEvent.getTime() == status.getTime()
&& !statics.isAdvancedRobot()
&& status.getGunHeadingRadians() == status.getRadarHeadingRadians()
&& ScannedRobotEvent.class.isAssignableFrom(currentTopEvent.getClass())) {
// this is angle assisted bullet
ScannedRobotEvent e = (ScannedRobotEvent) currentTopEvent;
double fireAssistAngle =
Utils.normalAbsoluteAngle(status.getHeadingRadians() + e.getBearingRadians());
bullet =
new Bullet(
fireAssistAngle, getX(), getY(), power, statics.getName(), null, true, nextBulletId);
wrapper = new BulletCommand(power, true, fireAssistAngle, nextBulletId);
} else {
// this is normal bullet
bullet =
new Bullet(
status.getGunHeadingRadians(),
getX(),
getY(),
power,
statics.getName(),
null,
true,
nextBulletId);
wrapper = new BulletCommand(power, false, 0, nextBulletId);
}
firedEnergy += power;
firedHeat += Rules.getGunHeat(power);
commands.getBullets().add(wrapper);
bullets.put(nextBulletId, bullet);
return bullet;
}
public void gameLoop() {
while (loop) {
message =
"Velkommen til Aktie Spillet!\n\n- Opfundet og kodet af Lars Quaade S�rensen\n\nV�lg en af f�lgende mulighederne:";
response =
JOptionPane.showOptionDialog(
null // Center in window.
,
message // Message
,
"Aktie Spillet" // Title in titlebar
,
JOptionPane.YES_NO_OPTION // Option type
,
JOptionPane.PLAIN_MESSAGE // messageType
,
null // Icon (none)
,
choices // Button text as above.
,
JOptionPane.YES_OPTION // Default button's label
);
if (response == JOptionPane.CLOSED_OPTION) {
System.exit(0);
}
if (response == 0) {
NewGame NG = new NewGame();
NG.newGame();
}
if (response == 1) {
ContinueGame CG = new ContinueGame();
CG.continueGame();
}
if (response == 2) {
Rules R = new Rules();
R.rules();
}
}
}
private static Rule<TextView> getRequiredRule(Field field, View view, Required required) {
if (!TextView.class.isAssignableFrom(view.getClass())) {
Log.w(TAG, String.format(WARN_TEXT, field.getName(), Required.class.getSimpleName()));
return null;
}
int messageResId = required.messageResId();
String message =
messageResId != 0 ? view.getContext().getString(messageResId) : required.message();
return Rules.required(message, required.trim());
}
private static Rule<Checkable> getCheckedRule(Field field, View view, Checked checked) {
if (!Checkable.class.isAssignableFrom(view.getClass())) {
Log.w(TAG, String.format(WARN_CHECKABLE, field.getName(), Checked.class.getSimpleName()));
return null;
}
int messageResId = checked.messageResId();
String message =
messageResId != 0 ? view.getContext().getString(messageResId) : checked.message();
return Rules.checked(message, checked.checked());
}
private static Rule<View> getEmailRule(Field field, View view, Email email) {
if (!TextView.class.isAssignableFrom(view.getClass())) {
Log.w(TAG, String.format(WARN_TEXT, field.getName(), Regex.class.getSimpleName()));
return null;
}
// int messageResId = email.messageResId();
// String message = messageResId != 0 ? view.getContext().getString(messageResId) :
// email.message();
// return Rules.or(message, Rules.eq(null, Rules.EMPTY_STRING), Rules.regex(message,
// Rules.REGEX_EMAIL, true));
int messageResId = email.messageResId();
String message =
messageResId != 0 ? view.getContext().getString(messageResId) : email.message();
if (email.empty()) {
return Rules.or(
message,
Rules.eq(null, Rules.EMPTY_STRING),
Rules.regex(message, Rules.REGEX_EMAIL, true));
}
List<Rule<?>> rules = new ArrayList<Rule<?>>();
rules.add(Rules.required(message, true));
rules.add(Rules.regex(message, Rules.REGEX_EMAIL, true));
Rule<?>[] ruleArray = new Rule<?>[rules.size()];
rules.toArray(ruleArray);
return Rules.and(message, ruleArray);
}
private static Rule<TextView> getConfirmPasswordRule(
Field field, View view, ConfirmPassword confirmPassword, TextView passwordTextView) {
if (!TextView.class.isAssignableFrom(view.getClass())) {
Log.w(TAG, String.format(WARN_TEXT, field.getName(), ConfirmPassword.class.getSimpleName()));
return null;
}
int messageResId = confirmPassword.messageResId();
String message =
messageResId != 0 ? view.getContext().getString(messageResId) : confirmPassword.message();
return Rules.eq(message, passwordTextView);
}
// Plays a card.
public static void handleRequestPlay(Message m) {
boolean heartsBroken = false;
if (m.info.equals("true")) heartsBroken = true;
Deck legal = Rules.extractLegalCards(hand, trick, heartsBroken);
Card c = randomCards(legal, 1).cardAt(0);
hand.remove(c);
Message m2 = new Message(Message.PLAY, null, c);
server.sendMessage(m2);
}
private static Rule<View> getPasswordRule(Field field, View view, Password password) {
if (!TextView.class.isAssignableFrom(view.getClass())) {
Log.w(TAG, String.format(WARN_TEXT, field.getName(), Password.class.getSimpleName()));
return null;
}
int messageResId = password.messageResId();
String message =
messageResId != 0 ? view.getContext().getString(messageResId) : password.message();
List<Rule<?>> rules = new ArrayList<Rule<?>>();
if (password.minLength() > 0) {
rules.add(Rules.minLength(null, password.minLength(), password.trim()));
}
if (password.maxLength() != Integer.MAX_VALUE) {
rules.add(Rules.maxLength(null, password.maxLength(), password.trim()));
}
Rule<?>[] ruleArray = new Rule<?>[rules.size()];
rules.toArray(ruleArray);
return Rules.and(message, ruleArray);
}
private Map createJdbcMetaDataProperty(TableInfo table, Rules rules, String field, boolean pk) {
String[] parts = field.split(":");
return map(
"headerKey",
parts[0],
"dataType",
(parts.length == 1 ? Types.string : Types.from(parts[1])).toString(),
"neoKey",
rules.propertyNameFor(table, field),
"primaryKey",
pk,
"index",
pk);
}
private void addRelationship(TableInfo table, Rules rules) {
if (table.fks.isEmpty()) return;
String tableName = table.table;
List<Map.Entry<List<String>, String>> fks = new ArrayList<>(table.fks.entrySet());
// todo multi-key
Map.Entry<List<String>, String> from = fks.get(0);
Map.Entry<List<String>, String> to = fks.get(1);
Map rel =
map(
"filename", tableName,
"name", rules.relTypeFor(tableName),
"from", createRelationshipNode(from.getValue(), from.getKey().get(0), rules),
"to", createRelationshipNode(to.getValue(), to.getKey().get(0), rules));
relationships.add(rel);
}
private static Rule<TextView> getRegexRule(Field field, View view, Regex regexRule) {
if (!TextView.class.isAssignableFrom(view.getClass())) {
Log.w(TAG, String.format(WARN_TEXT, field.getName(), Regex.class.getSimpleName()));
return null;
}
Context context = view.getContext();
int messageResId = regexRule.messageResId();
String message = messageResId != 0 ? context.getString(messageResId) : regexRule.message();
int patternResId = regexRule.patternResId();
String pattern =
patternResId != 0 ? view.getContext().getString(patternResId) : regexRule.pattern();
return Rules.regex(message, pattern, regexRule.trim());
}
private boolean eventToVP(
VerbChunk vc,
Word tg,
Word pr,
Word pr2,
List<Word> prep,
Map<String, Rules> rules[],
int ev_type,
boolean evt1,
boolean evt2,
boolean add) {
boolean prep1_pos, prep2_pos = false, prep_order = false, in_chunk = false;
String prep1 = "", prep2 = "", ctype, pos_type;
int count1 = 0, count2 = 0; // count2 -> for theme2/cause
boolean has_theme2 = false;
String childTrg = "", parentTrg = "";
if (vc.subject.belongTO(tg, pr, pr2)) {
eventToNP(vc.subject, tg, pr, pr2, prep, rules, ev_type, evt1, evt2, add);
} else if (vc.object.belongTO(tg, pr, pr2)) {
eventToNP(vc.object, tg, pr, pr2, prep, rules, ev_type, evt1, evt2, add);
} else if (vc.verb.contains(tg)) { // verb contains trigger
vppt++;
if (curr_event.getLevel(0) >= 2) {
vppt2++;
}
ctype = "VP";
pos_type = tg.pos_tag;
prep1_pos = tg.pos < pr.pos ? true : false;
if (pr2 == null) {
if (vc.subject.containsKey(pr)) {
count1 = vc.subject.getChunkPos(pr.pos);
// or relative clause
prep1 = getPrepFront(tg, pr, vc.subject);
} else if (vc.object.containsKey(pr)) {
count1 = vc.object.getChunkPos(pr.pos);
prep1 = getPrep(tg, pr, vc.object);
}
if (evt1) {
childTrg = pr.word;
}
} else { // Pr2!=null
// for both binding and regulatory events
has_theme2 = true;
prep2_pos = tg.pos < pr2.pos ? true : false;
if (prep1_pos && prep2_pos) { // both are behind trig
count1 = vc.object.getChunkPos(pr.pos);
count2 = vc.object.getChunkPos(pr2.pos);
if (pr.pos < pr2.pos) {
prep1 = getPrep(tg, pr, vc.object);
prep2 = getPrep2(pr, pr2, vc.object);
} else {
prep2 = getPrep(tg, pr2, vc.object);
prep1 = getPrep2(pr2, pr, vc.object);
}
} else if (prep1_pos && !prep2_pos) { // cause - tg - theme
prep1 = getPrep(tg, pr, vc.object);
prep2 = getPrepFront(tg, pr2, vc.subject);
count1 = vc.object.getChunkPos(pr.pos);
count2 = vc.subject.getChunkPos(pr2.pos);
} else if (!prep1_pos && prep2_pos) { // theme - tg - cause
prep1 = getPrepFront(tg, pr, vc.subject);
prep2 = getPrep(tg, pr2, vc.object);
count2 = vc.object.getChunkPos(pr2.pos);
count1 = vc.subject.getChunkPos(pr.pos);
} else if (!prep1_pos && !prep2_pos) { // both are in front of tg
// reg event: few cases, can skip
prep1 = getPrep2(pr, pr2, vc.subject);
prep2 = getPrepFront(tg, pr2, vc.subject);
count1 = vc.subject.getChunkPos(pr.pos);
count2 = vc.subject.getChunkPos(pr2.pos);
if (ev_type > 5) {
return false; // skip this case
}
}
if (ev_type
> 5) { // for binding events: the order of proteins always are PR1-PR2 if they are in
// the same side
if (evt1) {
childTrg = pr.word;
}
if (evt2) {
parentTrg = pr2.word;
}
}
}
Rules rl = rules[ev_type].get(tg.word);
if (rl == null) {
rl = new Rules(ev_type, tg.word);
rules[ev_type].put(tg.word, rl);
}
if (ev_type < 5) {
rl.addPattern(
vc.verb_type, pos_type, ctype, prep1_pos, prep1, in_chunk, count1, childTrg, add);
} else if (ev_type == 5) {
rl.addPattern(
vc.verb_type,
pos_type,
ctype,
prep1_pos,
prep2_pos,
prep_order,
prep1,
prep2,
has_theme2,
in_chunk,
count1,
count2,
childTrg,
add);
} else {
rl.addPattern(
vc.verb_type,
pos_type,
ctype,
prep1_pos,
prep2_pos,
prep_order,
prep1,
prep2,
has_theme2,
in_chunk,
count1,
count2,
evt1,
evt2,
childTrg,
parentTrg,
add);
}
} else { // merge subject and subject
BasicChunk new_ch = new BasicChunk();
new_ch.addChunk(vc.subject);
new_ch.addChunk(vc.verb);
new_ch.addChunk(vc.object);
new_ch.is_merged = true;
return eventToNP(new_ch, tg, pr, pr2, prep, rules, ev_type, evt1, evt2, add);
}
return true;
}
public double getVelocity() {
return Rules.getBulletSpeed(power);
}
private void combiningNP(Map<String, Rules> rl, Map<String, RuleSet> ruleset, int i) {
RuleSet rs;
String rkey;
int order1, order2;
Rules rule;
List<RuleData> ls;
String keys[] = {
"NNNP", "VBNP", "JJNP", "NNCP", "VBCP", "JJCP",
}; // noun, adj, vb in noun phrase
for (String s : rl.keySet()) {
rule = rl.get(s);
rule.initMap();
// process NP chunk
// cases to considered: PRO-TG (PRO)*
// TG prep1 PRO1 (prep2 PRO2)*
for (String subkey : keys) {
ls = rule.getEvalRules(subkey); // all NP pattern of current trg
if (ls == null) {
continue;
}
rkey = s + i + subkey; // trg + type + pos(first two letters) + chunk type
// has NP patterns
rs = new RuleSet();
order1 = 0;
order2 = 0;
for (RuleData dt : ls) {
if (dt.in_chunk) { // in chunk case
rs.in_chunk = true;
rs.inchunk_count += dt.count; // count number of inchunk event
if (!dt.has_cause) { // all event type without theme2/cause
if (dt.event1) {
rs.ecount += dt.count;
} else {
rs.pcount += dt.count;
}
} else if (i == 5 && dt.has_cause) { // theme2 PRO-TG PRO
rs.t2count += dt.count;
rs.pcount += dt.count;
rs.dist2 = Math.max(rs.dist2, dt.dist2);
} else if (i > 5 && dt.theme_pos && dt.has_cause) { // has cause
rs.pcause += dt.count; // assume only pro is cause : PRO - TG Theme (Pro/Evt)
if (dt.event1) {
rs.ecount += dt.count;
} else {
rs.pcount += dt.count;
}
rs.dist1 = Math.max(rs.dist1, dt.dist1);
}
} else if (dt.theme_pos) { // for all POS : TG - prep - PRO
if ((dt.POS.startsWith("NN") && !dt.prep1.isEmpty())
|| !dt.POS.startsWith("NN")) { // (NN && prep) or (VB/JJ)
if (!dt.has_cause) { // all event type, no theme2 / cause
if (i <= 5) {
rs.pcount += dt.count;
} else {
if (dt.event1) {
rs.ecount += dt.count;
} else {
rs.pcount += dt.count;
}
}
rs.dist1 = Math.max(rs.dist1, dt.dist1);
} else if (dt.cause_pos
&& !dt.prep2.isEmpty()
&& dt.POS.startsWith("NN")) { // TG-prep1-PRO1-prep2-PRO2 ; only NNx
if (i == 5) {
rs.t2count += dt.count;
rs.pcount += dt.count;
} else {
if (dt.event1) {
rs.ecount += dt.count;
} else {
rs.pcount += dt.count;
}
if (dt.event2) {
rs.ecause += dt.count;
} else {
rs.pcause += dt.count;
}
}
rs.dist1 = Math.max(rs.dist1, dt.dist1);
rs.dist2 = Math.max(rs.dist2, dt.dist2);
}
}
} else if (i == 5
&& !dt.theme_pos
&& ((dt.has_cause && dt.cause_pos)
|| !dt.POS.startsWith("NN"))) { // Binding: PRO1 - TG - PRO2
rs.in_front += dt.count;
if (!dt.prep2.isEmpty()) {
rs.prep_2.add(dt.prep2);
}
if (!dt.prep1.isEmpty()) {
rs.prep_1.add(dt.prep1);
}
rs.dist1 = Math.max(rs.dist1, dt.dist1);
rs.dist2 = Math.max(rs.dist2, dt.dist2);
rs.pcount += dt.count;
rs.dist2 = Math.max(rs.dist2, dt.dist2);
}
}
rs.detected = getCountDetectedTG(s, subkey);
if (order2 > order1) {
rs.order = false;
}
if (rs.getFreq() >= 2) {
ruleset.put(rkey, rs);
}
}
}
}
private void checkRobotCollision(List<RobotPeer> robots) {
for (RobotPeer otherRobot : robots) {
if (!(otherRobot == null || otherRobot == owner || otherRobot.isDead())
&& otherRobot.getBoundingBox().intersectsLine(boundingLine)) {
state = BulletState.HIT_VICTIM;
frame = 0;
victim = otherRobot;
double damage = Rules.getBulletDamage(power);
double score = damage;
if (score > otherRobot.getEnergy()) {
score = otherRobot.getEnergy();
}
otherRobot.updateEnergy(-damage);
boolean teamFire =
(owner.getTeamPeer() != null && owner.getTeamPeer() == otherRobot.getTeamPeer());
if (!teamFire) {
owner.getRobotStatistics().scoreBulletDamage(otherRobot.getName(), score);
}
if (otherRobot.getEnergy() <= 0) {
if (otherRobot.isAlive()) {
otherRobot.kill();
if (!teamFire) {
final double bonus = owner.getRobotStatistics().scoreBulletKill(otherRobot.getName());
if (bonus > 0) {
owner.println(
"SYSTEM: Bonus for killing "
+ (owner.getNameForEvent(otherRobot) + ": " + (int) (bonus + .5)));
}
}
}
}
owner.updateEnergy(Rules.getBulletHitBonus(power));
Bullet bullet = createBullet(false);
otherRobot.addEvent(
new HitByBulletEvent(
robocode.util.Utils.normalRelativeAngle(
heading + Math.PI - otherRobot.getBodyHeading()),
bullet));
owner.addEvent(
new BulletHitEvent(owner.getNameForEvent(otherRobot), otherRobot.getEnergy(), bullet));
double newX, newY;
if (otherRobot.getBoundingBox().contains(lastX, lastY)) {
newX = lastX;
newY = lastY;
setX(newX);
setY(newY);
} else {
newX = x;
newY = y;
}
deltaX = newX - otherRobot.getX();
deltaY = newY - otherRobot.getY();
break;
}
}
}
/** onScannedRobot: What to do when you see another robot */
public void onScannedRobot(ScannedRobotEvent e) {
System.out.println("START at : " + getTime() + " onScannedRobot----------------------------");
String nnn = e.getName();
System.out.println("scan " + nnn);
double eneX =
getX() + Math.sin(e.getBearingRadians() + Math.toRadians(getHeading())) * e.getDistance();
double eneY =
getY() + Math.cos(e.getBearingRadians() + Math.toRadians(getHeading())) * e.getDistance();
Enemy_info enem = null;
if (!isTeammate(nnn)) {
// 味方への情報送信
try {
broadcastMessage(
nnn
+ ", "
+ e.getBearing()
+ ", "
+ e.getBearingRadians()
+ ", "
+ e.getDistance()
+ ", "
+ e.getEnergy()
+ ", "
+ e.getHeading()
+ ", "
+ e.getHeadingRadians()
+ ", "
+ e.getVelocity()
+ ", "
+ eneX
+ ", "
+ eneY);
} catch (IOException ignored) {
}
// スキャンした車両がLocal敵リストにいるかどうかのフラグ
boolean flag = false;
System.out.println("send scanned info");
// スキャンした敵がLocal敵リストの中に存在するか
for (Enemy_info temp : enes) {
if (nnn.equals(temp.get_en_name())) {
flag = true;
enem = temp;
// Local敵リストのアップデート
temp.updateInformation(
e.getBearing(),
e.getBearingRadians(),
e.getDistance(),
e.getEnergy(),
e.getHeading(),
e.getHeadingRadians(),
e.getVelocity(),
eneX,
eneY);
System.out.println(" update scanned Info");
}
}
// スキャンした敵がLocal敵リストの中に存在しない場合
if (!flag) {
// Local敵リストに新規追加
enem =
new Enemy_info(
nnn,
e.getBearing(),
e.getBearingRadians(),
e.getDistance(),
e.getEnergy(),
e.getHeading(),
e.getHeadingRadians(),
e.getVelocity(),
eneX,
eneY);
enes.add(enem);
System.out.println(" add scanned info");
}
if (enemy_detected == false) {
// 共通の敵が設定されていない場合
enemy_detected = true;
target_enemy = enem;
try {
broadcastMessage("Kill , " + target_enemy.get_en_name() + ", !!");
} catch (IOException ignored) {
}
}
if (enemy_detected == true) {
try {
double enemyX = target_enemy.get_en_expX();
double enemyY = target_enemy.get_en_expY();
setTurnRadarLeftRadians(getRadarTurnRemainingRadians());
System.out.println("abs : eX " + enemyX + " : " + "eY " + enemyY);
// 共通の敵が設定されている場合
double enemyBearing = Math.atan((enemyX - getX()) / (enemyY - getY()));
// if(enemyBearing<0){
// System.out.println("change");
// enemyBearing = Math.PI*2 + enemyBearing;
// }else if (enemyBearing < Math.PI){
// }
// System.out.println("atan " + Math.atan((eneY-getY())/(eneX-getX())));
// System.out.println("atan1 " + Math.atan((eneX-getX())/(eneY-getY())));
// System.out.println("trueeee " + (e.getBearingRadians() + this.getHeadingRadians()));
System.out.println(
"enerad"
+ enemyBearing
+ " ?= "
+ "enemyBearing "
+ (this.getHeadingRadians() + e.getBearingRadians()));
System.out.println(enemyBearing + Math.PI);
double enemyHeading = target_enemy.get_en_heading(); // 敵の向き
System.out.println("enemy heading:" + enemyHeading);
// double enemyBearing = this.getHeadingRadians() +
// target_enemy.get_en_bearingRadians();// 自分と敵の角度
// double enemyX = target_enemy.get_en_distance() * Math.sin(enemyBearing);
// double enemyY = target_enemy.get_en_distance() * Math.cos(enemyBearing);
enemyX = enemyX - getX();
enemyY = enemyY - getY();
System.out.println("Relative : eX " + enemyX + " : " + "eY " + enemyY);
double battlefieldWidh = getBattleFieldWidth(); // フィールド幅
double battlefieldHeight = getBattleFieldHeight(); // フィールド高さ
boolean isHeadingToCenter = (int) enemyHeading % 90 == 0; // 中心を向いている
boolean isOnWall =
nearlyEquals(enemyX, 18)
|| nearlyEquals(enemyX + 18, battlefieldWidh)
|| nearlyEquals(enemyY, 18)
|| nearlyEquals(enemyY + 18, battlefieldHeight); // 壁に張り付いている
// 中心を向いている&&壁際にいる(=Walls)なら射撃
if (isHeadingToCenter && isOnWall) {
System.out.println("Walls!!");
}
double dis = 0;
double heading = lastEnemyHeading;
do {
dis += Rules.getBulletSpeed(power);
heading += target_enemy.get_en_headingRadians() - lastEnemyHeading;
enemyX += target_enemy.get_en_velocity() * Math.sin(heading);
enemyY += target_enemy.get_en_velocity() * Math.cos(heading);
} while (dis < Point2D.distance(0, 0, enemyX, enemyY)); //
// 相対角度に変換した上で砲塔の向きを変える
setTurnGunRightRadians(
Utils.normalRelativeAngle(Math.atan2(enemyX, enemyY) - getGunHeadingRadians()));
setFire(power);
// lastEnemyHeading = e.getHeadingRadians();
lastEnemyHeading = target_enemy.get_en_headingRadians();
System.out.println("lastEnemyHeading " + e.getHeadingRadians());
System.out.println(lastEnemyHeading);
// 敵の居る方向へターンする
// setTurnRightRadians(e.getBearingRadians());
setTurnRightRadians(enemyBearing - this.getHeadingRadians());
System.out.println("setTurnRightRadians " + e.getBearingRadians());
System.out.println(enemyBearing - this.getHeadingRadians());
// 前進する
setAhead(moveAmount);
} catch (NullPointerException ee) {
System.out.println("NullPointerException");
System.out.println(target_enemy);
}
}
}
System.out.println("enemy_detected = " + enemy_detected);
System.out.println("target is " + target_enemy.get_en_name());
System.out.println(target_enemy.get_en_expX() + " " + target_enemy.get_en_expY());
System.out.println("END at : " + getTime() + " onScannedRobot----------------------------");
}
/**
* according to .gwt.xml files generates a LinkedMap which has interfaces as keys array of
* generators as values keys are sorted according order of <generate-with> elements in .gwt.xml
* files
*
* @param context
* @throws UnableToCompleteException
*/
private void fillUpGeneratorChainMap(TreeLogger logger, GeneratorContext context)
throws UnableToCompleteException {
GeneratorChain.customGenerators = new LinkedList<AbstractGenerator>();
GeneratorChain.replacers = new LinkedList<AbstractGenerator>();
GeneratorChain.thirdPartyGenerators = new LinkedHashMap<Generator, AbstractGenerator>();
ModuleDef moduleDef =
((CompilerContext) getPrivateField(context, "compilerContext")).getModule();
Rules rules = moduleDef.getRules();
Iterator<Rule> rulesIter = rules.iterator();
while (rulesIter.hasNext()) {
Rule rul = rulesIter.next();
Generator gen = null;
// =================replace with
if (rul instanceof RuleReplaceWith) {
String replaceClass = (String) getPrivateField(rul, "replacementTypeName");
gen = new ReplaceByGenerator(replaceClass);
// gen = null;
// =================generate with
} else if (rul instanceof RuleGenerateWith) {
Class<? extends Generator> generatorClass =
(Class<? extends Generator>) getPrivateField(rul, "generatorClass");
Constructor<?> constructor;
try {
constructor = generatorClass.getDeclaredConstructor();
} catch (Exception e) {
logger.log(
Type.ERROR, "Unable to obtain default constructor of generator " + generatorClass);
throw new UnableToCompleteException();
}
constructor.setAccessible(true);
try {
gen = (Generator) constructor.newInstance();
} catch (Exception e) {
logger.log(Type.ERROR, "Unable to create instance of generator " + generatorClass);
throw new UnableToCompleteException();
}
}
if (gen != null) {
if (gen instanceof AbstractGenerator) {
GenPredicGroup newGroup = null;
AbstractGenerator myGen = (AbstractGenerator) gen;
if (GeneratorChain.customGenerators.contains(gen)
|| GeneratorChain.replacers.contains(gen)) {
newGroup = addPredicsToExisting(rul, myGen.getConditions());
myGen.setConditions(newGroup);
} else {
newGroup = getGroupConditions(rul.getRootCondition().getConditions(), null);
myGen.setConditions(newGroup);
if (gen instanceof ReplaceByGenerator) {
GeneratorChain.replacers.addFirst(myGen);
} else {
GeneratorChain.customGenerators.addFirst(myGen);
}
}
} else {
if (GeneratorChain.thirdPartyGenerators.containsKey(gen)) {
AbstractGenerator myGen = GeneratorChain.thirdPartyGenerators.get(gen);
GenPredicGroup newGroup = addPredicsToExisting(rul, myGen.getConditions());
myGen.setConditions(newGroup);
GeneratorChain.thirdPartyGenerators.put(gen, myGen);
} else {
AbstractGenerator myGen =
new AbstractGenerator() {
@Override
public String doGenerate(
TreeLogger logger, GeneratorContext context, String typeName)
throws UnableToCompleteException {
return null;
}
};
myGen.setConditions(getGroupConditions(rul.getRootCondition().getConditions(), null));
GeneratorChain.thirdPartyGenerators.put(gen, myGen);
}
}
}
}
}
private Rules rulesFromFile(String path) {
InputStream is = this.getClass().getResourceAsStream(path);
Rules result = new Rules(Util.readFile(is));
result.setRulesSource(Rules.RulesSourceEnum.DEFAULT);
return result;
}
/**
* updates the rules to the given values.
*
* @param updatedRules latest rules
* @return a copy of the latest rules
*/
@Transactional
public Rules update(Rules updatedRules) {
updatedRules.setRulesSource(Rules.RulesSourceEnum.DATABASE);
Rules result = this.create(updatedRules);
return result;
}
