private void pickSmart() {
this.buildingFound = false;
synchronized (ContextManager.randomLock) {
Collections.shuffle(GlobalVars.burgleMap); // Shuffle the map
for (Building b : GlobalVars.burgleMap) {
// TODO: Tune this logic for Objective #2 of the project. Consider game theory or some other
// type
// of SoS decision making process to decide if it is best to travel to burgle location
// or
// prevent other burgles by traveling to less-burgled parts of the map (e.g. replace
// the 25%
// value with "game theory" idea where the cost/benefits are adjusted (trade study) to
// analyze behavior on crime
Uniform uniform = RandomHelper.createUniform(0, 1);
if (uniform.nextDouble()
< GlobalVars.probTraveltoRecentCrime) { // 25% chance of traveling near recent crime
if ((b.jurisdiction == this.jurisdiction) && !(this.burgleMapSave.contains(b))) {
this.b_pick = b;
this.route = new Route(this, b.getCoords(), b_pick); // Initialize route to target;
this.buildingFound = true;
this.burgleMapSave.add(b);
break; // stop searching
}
}
}
if (this.buildingFound == false) {
pickRandom(); // no previously burgled building exists in memory map for given jurisdiction
}
}
}
/**
* Returns <code>true</code> or <code>false</code> with the specified probability.
*
* @param threshold the actual threshold level to use
* @return Returns <code>true</code> if a random number chosen from the <code>[0,1)</code>
* interval is smaller than the parameter; <code>false</code> otherwise
* @since Model 12
*/
public static boolean prob(final double threshold) {
if (threshold < 0.0 || 1.0 < threshold) {
throw new IllegalArgumentException(
String.format("Parameter threshold=%f should be in interval [0, 1].", threshold));
}
return (threshold < RandomHelper.nextDouble());
}
/**
* Returns a random element of the specified arbitrary list.
*
* @param list the list to select a random element from; <i>cannot be <code>null</code> or
* empty</i>
* @return a random element of the specified list using the default random generator of {@link
* RandomHelper}
*/
public static <T> T randomElementOf(final List<T> list) {
if (null == list) {
throw new IllegalArgumentException("Parameter list cannot be null.");
}
if (list.isEmpty()) {
throw new IllegalArgumentException("Cannot return a random element from an empty list.");
}
return list.get(RandomHelper.nextIntFromTo(0, list.size() - 1));
}
public boolean trySanction(Soldiers s) {
// probability for the sanction in display!set a new parameter!
sanctionProbability = sanctionProbability * 1.1;
sanctionProbability = sanctionProbability > 1.0 ? 1.0 : sanctionProbability;
// sanctionProbability =;
double rnd = RandomHelper.nextDoubleFromTo(0.0, 1.0);
if (rnd <= sanctionProbability) {
sanction(s);
return true;
}
return false;
}
public void giveExtorsionMoney(double amount, Soldiers soldier, Shop shop, Color territory) {
// store money
// distribute money
// 50 persent for capos, then rest for solidiers
System.out.println(
"capo #"
+ this.getIndex()
+ "cummulatedIncome = "
+ cummulatedIncome
+ "extorsionCount = "
+ extorsionCount);
extorsionCount++;
cummulatedIncome += amount * 0.5;
soldier.setMoney(soldier.getMoney() + amount * 0.5);
System.out.println("capo #" + index + " has now: $" + cummulatedIncome);
// draw edges between Capo and by own soldiers extorted shops
Context<Object> context = ContextUtils.getContext(this);
Network<Object> net = (Network<Object>) context.getProjection("network");
net.addEdge(this, shop);
// sanction if money from shop from other territory
if (!territory.equals(familyColor)) {
// decision process --> preliminary! --- TODO: could be implemented
// with EMIL-S
notPermittedExtorsionCount++;
double rnd = RandomHelper.nextDoubleFromTo(0.0, 1.0);
if (rnd <= sanctionProbability) {
soldier.sanction(shop, territory);
sanctionCount++;
}
}
// notify the mandamento
if (this != mandamento.getCapo()) {
mandamento.onExtortMoney(index, cummulatedIncome);
}
}
@ScheduledMethod(start = 1, interval = 1)
public void step() {
// get the grid location of this Zombie
GridPoint pt = grid.getLocation(this);
// use the GridCellNgh class to create GridCells for
// the surrounding neighborhood .
GridCellNgh<Human> nghCreator = new GridCellNgh<Human>(grid, pt, Human.class, 1, 1);
List<GridCell<Human>> gridCells = nghCreator.getNeighborhood(true);
SimUtilities.shuffle(gridCells, RandomHelper.getUniform());
GridPoint pointWithMostHumans = null;
int maxCount = -1;
for (GridCell<Human> cell : gridCells) {
if (cell.size() > maxCount) {
pointWithMostHumans = cell.getPoint();
maxCount = cell.size();
}
}
moveTowards(pointWithMostHumans);
infect();
}
public void infect() {
GridPoint pt = grid.getLocation(this);
List<Object> humans = new ArrayList<Object>();
for (Object obj : grid.getObjectsAt(pt.getX(), pt.getY())) {
if (obj instanceof Human) {
humans.add(obj);
}
}
if (humans.size() > 0) {
int index = RandomHelper.nextIntFromTo(0, humans.size() - 1);
Object obj = humans.get(index);
NdPoint spacePt = space.getLocation(obj);
Context<Object> context = ContextUtils.getContext(obj);
context.remove(obj);
Zombie zombie = new Zombie(space, grid);
context.add(zombie);
space.moveTo(zombie, spacePt.getX(), spacePt.getY());
grid.moveTo(zombie, pt.getX(), pt.getY());
Network<Object> net = (Network<Object>) context.getProjection("infection network");
net.addEdge(this, zombie);
}
}
@ScheduledMethod(start = 1, interval = 1)
public void step() {
// create colNetwork in hosting context
Context<Object> context = ContextUtils.getContext(this);
Network<Object> colNet = (Network<Object>) context.getProjection("collaboration_network");
Network<Object> userNet = (Network<Object>) context.getProjection("user_network");
Network<Object> articleNet = (Network<Object>) context.getProjection("article_network");
if (!isDone) {
/*
* Neighbourhood Connection Algorithm
*/
// get the grid location of this User
GridPoint pt = grid.getLocation(this);
// use the GridCellNgh class to create GridCells for
// the surrounding neighbourhood
if (pt != null) { // TODO Why NULL?
GridCellNgh<Article> nghCreator =
new GridCellNgh<Article>(
grid, pt, Article.class, neighbourDimensions, neighbourDimensions);
List<GridCell<Article>> gridCells = nghCreator.getNeighborhood(false);
SimUtilities.shuffle(gridCells, RandomHelper.getUniform());
// if an agent exist in the surrounding environment, add an edge with it.
for (GridCell<Article> cell : gridCells) {
if (cell.size() > 0) {
List<Article> cellUsers = new ArrayList<Article>((Collection<Article>) cell.items());
articleToEdit = cellUsers.get((RandomHelper.nextIntFromTo(0, cellUsers.size() - 1)));
if (context != null && colNet != null && cellUsers != null && articleToEdit != null) {
if (!isActiveUser) { // Good Samaritan - one and only one connection
if (colNet.getDegree(articleToEdit) <= 0 // if neighbour is unconnected
&& colNet.getDegree(this) <= 0) { // if our agent is unconnected)
colNet.addEdge(this, articleToEdit);
this.isDone =
true; // this good samaritan is no longer counted in operating agents
}
} else if (!hasGeneralInterest) { // Project Leader zealot (active user),
colNet.addEdge(this, articleToEdit); // connects neighbours in every step
for (Object coopUser : colNet.getAdjacent(articleToEdit)) {
if (coopUser != null && !userNet.containsEdge(userNet.getEdge(this, coopUser))) {
userNet.addEdge(this, coopUser);
}
}
for (Object relatedArticle : colNet.getAdjacent(this)) {
if (relatedArticle != null
&& !articleNet.containsEdge(userNet.getEdge(articleToEdit, relatedArticle))) {
articleNet.addEdge(articleToEdit, relatedArticle);
}
}
}
// For active agent connection algorithm we need to update good article array if found
if (colNet.getDegree(articleToEdit)
> (goodArticleMultiplier * colNet.getDegree() / colNet.size())
&& colNet.getDegree(articleToEdit) > goodArticleConnectionCount
&& !articleToEdit.isGood) {
articleToEdit.isGood = true;
goodArticles.add(articleToEdit);
}
}
break;
}
}
}
/*
* Active Agent Connection Algorithm
*/
if (isActiveUser
&& hasGeneralInterest
&& goodArticles.size() > 0) { // if in administrator career path
articleToEdit = goodArticles.get(RandomHelper.nextIntFromTo(0, goodArticles.size() - 1));
colNet.addEdge(this, articleToEdit); // TODO reduce goodArticles by one?
for (Object coopUser : colNet.getAdjacent(articleToEdit)) {
if (coopUser != null && !userNet.containsEdge(userNet.getEdge(this, coopUser))) {
userNet.addEdge(this, coopUser);
}
}
for (Object relatedArticle : colNet.getAdjacent(this)) {
if (relatedArticle != null
&& !articleNet.containsEdge(userNet.getEdge(articleToEdit, relatedArticle))) {
articleNet.addEdge(articleToEdit, relatedArticle);
}
}
goodArticles.remove(0);
}
this.endRun();
}
}
public class RainContext {
private Grid<Object> grid;
private int noRainGroups;
private static final Uniform urng = RandomHelper.getUniform();
Random rand = new Random();
private ArrayList<RainGroup> rainGroups = new ArrayList<RainGroup>();
private int strength;
public RainContext(Grid<Object> grid) {
this.grid = grid;
this.noRainGroups = 0;
}
/**
* Rain clouds appear with a certain chance, influenced by the weather For every rain cloud in the
* grid the velocity of every rain object is updated Rain clouds are removed if they have passed a
* certain time
*/
@ScheduledMethod(start = 1, interval = 1, priority = 0)
public void rain() {
// Let new raingroups appear with a certain chance
double chance = SimulationParameters.rainProb;
// The probability of rain appearing decreases if there is already rain in the grid
if (noRainGroups == 1) chance = (chance / (noRainGroups)) * 0.5;
if (noRainGroups == 2) chance = (chance / (noRainGroups)) * 0.1;
if (noRainGroups > 2) chance = (chance / (noRainGroups)) * 0.01;
double f = urng.nextDouble();
if (f < chance) {
// Let rain appear
int x = rand.nextInt((SimulationParameters.gridSize - 0) + 1);
int y = rand.nextInt((SimulationParameters.gridSize - 0) + 1);
int[] newLoc = {x, y};
// Let new raingroup appear in random location
RainGroup rg = new RainGroup(ContextUtils.getContext(this), grid, newLoc);
noRainGroups++;
rainGroups.add(rg);
}
ArrayList<RainGroup> toRemove = new ArrayList<RainGroup>();
for (RainGroup rg : rainGroups) {
// Get velocity vector of the rain
float x = Wind.getWindVelocity().x;
float y = Wind.getWindVelocity().y;
Vector2 velRain = new Vector2(x, y);
velRain.setLength(
Wind.getWindVelocity().len() * 0.9f); // Rain speed is a bit lower than that of the wind
List<Rain> toRemove1 = new ArrayList<Rain>();
// Let rain be carried by the wind
if (urng.nextDouble() < velRain.len()) {
for (Rain rain : rg.getRainObjects()) {
Directions dir = Directions.fromVectorToDir(velRain);
GridPoint pt = grid.getLocation(rain);
int cX = pt.getX() + dir.xDiff;
int cY = pt.getY() + dir.yDiff;
// If new rain-location is out of borders, delete this rain object
// In this way the cloud "travels" out of the grid
if (cX < 0
|| cX >= SimulationParameters.gridSize
|| cY < 0
|| cY >= SimulationParameters.gridSize) {
toRemove1.add(rain);
} else grid.moveTo(rain, cX, cY);
}
}
for (Rain r : toRemove1) {
rg.removeRain(r);
TreeBuilder.performance.decreaseRainCount();
}
}
// Remove the raingroups from our list which were removed from the context
for (RainGroup rg : toRemove) {
rainGroups.remove(rg);
noRainGroups--;
}
}
}