mirror of
https://github.com/guilhermewerner/site-pi
synced 2025-06-16 22:04:22 +00:00
283 lines
8.9 KiB
C#
283 lines
8.9 KiB
C#
|
|
package com.mycompany.mavenproject1;
|
|
|
|
import java.util.Set;
|
|
import java.util.logging.Level;
|
|
|
|
import cz.cuni.amis.pogamut.base.agent.navigation.IPathExecutorState;
|
|
import cz.cuni.amis.pogamut.base.agent.navigation.PathExecutorState;
|
|
import cz.cuni.amis.pogamut.base.utils.guice.AgentScoped;
|
|
import cz.cuni.amis.pogamut.base.utils.math.DistanceUtils;
|
|
import cz.cuni.amis.pogamut.base3d.worldview.object.ILocated;
|
|
import cz.cuni.amis.pogamut.ut2004.agent.module.sensor.visibility.Visibility;
|
|
import cz.cuni.amis.pogamut.ut2004.agent.module.sensor.visibility.VisibilityCreator;
|
|
import cz.cuni.amis.pogamut.ut2004.agent.module.utils.TabooSet;
|
|
import cz.cuni.amis.pogamut.ut2004.agent.navigation.UT2004PathAutoFixer;
|
|
import cz.cuni.amis.pogamut.ut2004.bot.impl.UT2004BotModuleController;
|
|
import cz.cuni.amis.pogamut.ut2004.communication.messages.gbcommands.Initialize;
|
|
import cz.cuni.amis.pogamut.ut2004.communication.messages.gbinfomessages.BotKilled;
|
|
import cz.cuni.amis.pogamut.ut2004.communication.messages.gbinfomessages.ConfigChange;
|
|
import cz.cuni.amis.pogamut.ut2004.communication.messages.gbinfomessages.GameInfo;
|
|
import cz.cuni.amis.pogamut.ut2004.communication.messages.gbinfomessages.InitedMessage;
|
|
import cz.cuni.amis.pogamut.ut2004.communication.messages.gbinfomessages.NavPoint;
|
|
import cz.cuni.amis.pogamut.ut2004.communication.messages.gbinfomessages.Player;
|
|
import cz.cuni.amis.pogamut.ut2004.utils.UT2004BotRunner;
|
|
import cz.cuni.amis.utils.Cooldown;
|
|
import cz.cuni.amis.utils.Heatup;
|
|
import cz.cuni.amis.utils.collections.MyCollections;
|
|
import cz.cuni.amis.utils.exception.PogamutException;
|
|
import cz.cuni.amis.utils.flag.FlagListener;
|
|
|
|
/**
|
|
* Example of Pogamut Bot that is utilizing {@link Visibility} module.
|
|
*
|
|
* Must be run on DM-1on1-Albatross. If you want to use different map
|
|
* read javadoc for {@link Visibility} and {@link VisibilityCreator}.
|
|
*
|
|
* @author Jakub Gemrot aka Jimmy
|
|
*/
|
|
@AgentScoped
|
|
public class HideBot extends UT2004BotModuleController {
|
|
|
|
/**
|
|
* Taboo set is working as "black-list", that is you might add some
|
|
* NavPoints to it for a certain time, marking them as "unavailable".
|
|
*/
|
|
protected TabooSet<NavPoint> tabooNavPoints;
|
|
|
|
/**
|
|
* Used for autofixing navpoints.
|
|
*/
|
|
protected UT2004PathAutoFixer autoFixer;
|
|
|
|
/**
|
|
* Here we can modify initializing command for our bot.
|
|
*
|
|
* @return
|
|
*/
|
|
@Override
|
|
public Initialize getInitializeCommand() {
|
|
return new Initialize().setName("HideBot");
|
|
}
|
|
|
|
/**
|
|
* The bot is initialized in the environment - a physical representation of
|
|
* the bot is present in the game.
|
|
*
|
|
* @param config information about configuration
|
|
* @param init information about configuration
|
|
*/
|
|
@SuppressWarnings("unchecked")
|
|
@Override
|
|
public void botInitialized(GameInfo gameInfo, ConfigChange config, InitedMessage init) {
|
|
// initialize taboo set where we store temporarily unavailable navpoints
|
|
tabooNavPoints = new TabooSet<NavPoint>(bot);
|
|
|
|
// auto-removes wrong navigation links between navpoints
|
|
autoFixer = new UT2004PathAutoFixer(bot, navigation.getPathExecutor(), fwMap, aStar, navBuilder);
|
|
|
|
// IMPORTANT
|
|
// adds a listener to the path executor for its state changes, it will allow you to
|
|
// react on stuff like "PATH TARGET REACHED" or "BOT STUCK"
|
|
navigation.getPathExecutor().getState().addStrongListener(new FlagListener<IPathExecutorState>() {
|
|
|
|
@Override
|
|
public void flagChanged(IPathExecutorState changedValue) {
|
|
pathExecutorStateChange(changedValue.getState());
|
|
}
|
|
});
|
|
}
|
|
|
|
Player hidingFrom;
|
|
|
|
Heatup hiding = new Heatup(10000);
|
|
|
|
Cooldown turning = new Cooldown(1200);
|
|
|
|
NavPoint targetNavPoint;
|
|
|
|
Cooldown changeNavPoint = new Cooldown(2000);
|
|
|
|
@Override
|
|
public void logic() {
|
|
|
|
if (!visibility.isInitialized()) {
|
|
log.warning("Could not use VISIBILITY module :-(");
|
|
return;
|
|
}
|
|
|
|
Player visible = players.getNearestVisiblePlayer();
|
|
|
|
if (hidingFrom != null) {
|
|
|
|
if (visible != hidingFrom) {
|
|
if (!hidingFrom.isVisible()) {
|
|
// SWITCH ATTENTION
|
|
startRunningAwayFrom(visible);
|
|
return;
|
|
}
|
|
|
|
if (info.getLocation().getDistance(visible.getLocation()) < info.getLocation().getDistance(hidingFrom.getLocation())) {
|
|
// SWITCH ATTENTION
|
|
startRunningAwayFrom(hidingFrom);
|
|
return;
|
|
}
|
|
}
|
|
|
|
continueRunningAwayFrom();
|
|
return;
|
|
}
|
|
|
|
if (visible != null) {
|
|
startRunningAwayFrom(visible);
|
|
return;
|
|
}
|
|
|
|
if (navigation.isNavigating()) {
|
|
navigation.stopNavigation();
|
|
navigation.setFocus(null);
|
|
}
|
|
|
|
if (turning.tryUse()) {
|
|
move.turnHorizontal(110);
|
|
}
|
|
|
|
}
|
|
|
|
private void startRunningAwayFrom(Player enemy) {
|
|
this.hidingFrom = enemy;
|
|
NavPoint cover = getCoverNavPoint(enemy);
|
|
|
|
if (cover == null) {
|
|
log.warning("No suitable navpoint, standing still... :-(");
|
|
return;
|
|
}
|
|
|
|
navigation.setFocus(enemy);
|
|
runTo(cover);
|
|
}
|
|
|
|
private NavPoint getCoverNavPoint(ILocated enemy) {
|
|
Set<NavPoint> navPoints = visibility.getCoverNavPointsFrom(enemy);
|
|
|
|
NavPoint cover = DistanceUtils.getNearestFiltered(navPoints, info.getLocation(), tabooNavPoints);
|
|
|
|
if (cover != null) return cover;
|
|
|
|
log.warning("Could not use any navpoint as cover... trying random one.");
|
|
return getRandomNavPoint();
|
|
}
|
|
|
|
private void continueRunningAwayFrom() {
|
|
if (hidingFrom == null) {
|
|
log.warning("hidingFrom == null ???");
|
|
return;
|
|
}
|
|
|
|
if (navigation.isNavigating()) {
|
|
NavPoint suitableNavPoint = getCoverNavPoint(hidingFrom);
|
|
if (targetNavPoint != suitableNavPoint) {
|
|
if (changeNavPoint.tryUse()) {
|
|
runTo(suitableNavPoint);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
// NOT NAVIGATING!
|
|
if (targetNavPoint != null) {
|
|
tabooNavPoints.add(targetNavPoint, 30);
|
|
}
|
|
|
|
if (hidingFrom.isVisible()) {
|
|
startRunningAwayFrom(hidingFrom);
|
|
return;
|
|
}
|
|
|
|
// NOT NAVIGATING! Player not visible...
|
|
this.hidingFrom = null;
|
|
}
|
|
|
|
|
|
private void runTo(NavPoint navPoint) {
|
|
log.info("Running to: " + navPoint);
|
|
targetNavPoint = navPoint;
|
|
navigation.navigate(targetNavPoint);
|
|
}
|
|
|
|
/**
|
|
* Called each time our bot die. Good for reseting all bot state dependent variables.
|
|
*
|
|
* @param event
|
|
*/
|
|
@Override
|
|
public void botKilled(BotKilled event) {
|
|
navigation.stopNavigation();
|
|
targetNavPoint = null;
|
|
hidingFrom = null;
|
|
hiding.clear();
|
|
turning.clear();
|
|
changeNavPoint.clear();
|
|
}
|
|
|
|
/**
|
|
* Path executor has changed its state (note that {@link UT2004BotModuleController${symbol_pound}getPathExecutor()}
|
|
* is internally used by
|
|
* {@link UT2004BotModuleController${symbol_pound}getNavigation()} as well!).
|
|
*
|
|
* @param state
|
|
*/
|
|
protected void pathExecutorStateChange(PathExecutorState state) {
|
|
switch (state) {
|
|
case PATH_COMPUTATION_FAILED:
|
|
// if path computation fails to whatever reason, just try another navpoint
|
|
// taboo bad navpoint for 3 minutes
|
|
tabooNavPoints.add(targetNavPoint, 180);
|
|
break;
|
|
|
|
case TARGET_REACHED:
|
|
tabooNavPoints.add(targetNavPoint, 5);
|
|
break;
|
|
|
|
case STUCK:
|
|
// the bot has stuck! ... target nav point is unavailable currently
|
|
tabooNavPoints.add(targetNavPoint, 60);
|
|
break;
|
|
|
|
case STOPPED:
|
|
// path execution has stopped
|
|
targetNavPoint = null;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Randomly picks some navigation point to head to.
|
|
*
|
|
* @return randomly choosed navpoint
|
|
*/
|
|
protected NavPoint getRandomNavPoint() {
|
|
log.info("Picking new target navpoint.");
|
|
|
|
// choose one feasible navpoint (== not belonging to tabooNavPoints) randomly
|
|
NavPoint chosen = MyCollections.getRandomFiltered(getWorldView().getAll(NavPoint.class).values(), tabooNavPoints);
|
|
|
|
if (chosen != null) {
|
|
return chosen;
|
|
}
|
|
|
|
log.warning("All navpoints are tabooized at this moment, choosing navpoint randomly!");
|
|
|
|
// ok, all navpoints have been visited probably, try to pick one at random
|
|
return MyCollections.getRandom(getWorldView().getAll(NavPoint.class).values());
|
|
}
|
|
|
|
public static void main(String args[]) throws PogamutException {
|
|
// wrapped logic for bots executions, suitable to run single bot in single JVM
|
|
|
|
// we're forcingly setting logging to aggressive level FINER so you can see (almost) all logs
|
|
// that describes decision making behind movement of the bot as well as incoming environment events
|
|
new UT2004BotRunner(HideBot.class, "HideBot").setMain(true).setLogLevel(Level.INFO).startAgent();
|
|
}
|
|
}
|