void handleConfigEvent(HashMap map) {
if (map == null) {
return;
}
if (map.containsKey("additional_data")) {
additional_data = (byte[]) map.get("additional_data");
}
if (map.containsKey("send_buf_size")) {
mcast_send_buf_size = ((Integer) map.get("send_buf_size")).intValue();
ucast_send_buf_size = mcast_send_buf_size;
}
if (map.containsKey("recv_buf_size")) {
mcast_recv_buf_size = ((Integer) map.get("recv_buf_size")).intValue();
ucast_recv_buf_size = mcast_recv_buf_size;
}
setBufferSizes();
}
public ArrayList getPointList(long handId) {
ArrayList curList;
if (_pointLists.containsKey(handId)) curList = (ArrayList) _pointLists.get(handId);
else {
curList = new ArrayList(_maxPoints);
_pointLists.put(handId, curList);
}
return curList;
}
/**
* Obtient le socket enregistré correspondant à l'addresse IP donnée.
*
* @return le socket correspondant à l'IP source donnée s'il a été enregistré null sinon.
*/
public Socket popSocket(InetAddress addr) {
String addrname = toId(addr);
if (acceptedSockets.containsKey(addrname)) {
Socket sock = acceptedSockets.get(addrname);
acceptedSockets.remove(addrname);
return sock;
}
return null;
}
public void OnPointDestroy(long nID) {
println("OnPointDestroy, handId: " + nID);
// remove list
if (_pointLists.containsKey(nID)) _pointLists.remove(nID);
}
public static void main(String[] args) throws IOException {
System.out.println("SimultaneousAscendingAuctionClient starting");
Socket auctSocket = null;
PrintWriter out = null;
BufferedReader in = null;
String hostName = "127.0.0.1"; // IP of host (may be local IP)
int socketNum = 1305; // the luckiest socket
Agent agent = null;
Valuation valuationMethod = null;
try {
in = new BufferedReader(new FileReader("./src/IP_and_Port.txt"));
// two lines in this file. First is hostName/IP address, and second is socket number of host
hostName = in.readLine();
socketNum = Integer.valueOf(in.readLine());
in.close();
} catch (IOException e) {
}
// These are values the agent should remember and use
// Values are initialized when Server sends parameters
int numSlotsNeeded = -1;
int deadline = -1;
double[] valuations = null;
try {
auctSocket = new Socket(hostName, socketNum);
out = new PrintWriter(auctSocket.getOutputStream(), true);
in = new BufferedReader(new InputStreamReader(auctSocket.getInputStream()));
} catch (UnknownHostException e) {
System.err.println("Don't know about host: " + hostName + ".");
System.exit(1);
} catch (IOException e) {
System.err.println("Couldn't get I/O for the connection to: host.");
System.exit(1);
}
System.out.println("Connection to host established");
BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in));
String fromServer;
// continue to prompt commands from host and respond
while ((fromServer = in.readLine()) != null) {
System.out.println("Server: " + fromServer);
// Send host this client's unique ID
if (fromServer.equalsIgnoreCase("Send client name")) {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.println("Enter a unique ID string...");
out.println(br.readLine());
// OPTIONAL CHANGE:
// YOU MAY CHOOSE TO REPLACE THE LINE ABOVE WITH THE LINE BELOW
// out.println("My_Hardcoded_Name");
System.out.println("User ID sent. If prompted again, choose another ID/Name string.");
System.out.println("Waiting for server to start auction...");
}
// ***********************************************************************
else if (fromServer.startsWith("agent-parameters:")) {
String[] params = fromServer.split("[ ]"); // tokens delimited with spaces
numSlotsNeeded = Integer.valueOf(params[1]); // 1st param is number of slots needed
deadline = Integer.valueOf(params[2]); // 2nd param is deadline
// DEADLINE IS INDEX OF LAST AUCTION OF VALUE (0-indexed).
// example: deadline = 1 --> first two time-slots can be used
valuations = new double[params.length - 3]; // first 3 stings aren't valuations
for (int i = 3; i < params.length; i++) valuations[i - 3] = Double.valueOf(params[i]);
///////////////////////////////////////////////
// YOUR CODE HERE
// You probably want to store the parameters sent from host.
// For example, you could store them in global variables,
// or use them to initialize an agent class you wrote.
///////////////////////////////////////////////
// EDIT HERE
// ?? how to define the number for each agent ?
// ?? whether to change to another kind of agent
valuationMethod = new SchedulingValuation(numSlotsNeeded, valuations);
agent = new SunkawarePPAgent(0, valuationMethod, 0);
// Send starting information= to agents
// agent.postResult(new Result(null, false, 0, ar.getAskPrice(), 0, ar.getAskEpsilon()));
agent.openAllAuctions();
///////////////////////////////////////////////
out.println("Parameters accepted");
}
// ***********************************************************************
else if (fromServer.equalsIgnoreCase("submit-bid")) {
// Here are values you should use... be more clever than random!
// numSlotsNeeded (int)
// deadline (int) index of last timeSlot of value (starts at 0)
// valuations (double[numSlots])
///////////////////////////////////////////////
// YOUR CODE HERE
// Create a string, like myBids, with your bid(s).
// If placing multiple bids, separate bids with spaces spaces.
// If multiple bids, order bids as follows:
// myBids = "timeSlot1Bid timeSlot2Bid ... timeslot5Bid";
//
// Note: bids get rounded to 2 decimal places by host. 5.031 -> 5.03
///////////////////////////////////////////////
/*
String myBids = "";
Random r = new Random();//make random bids... 1 for each time slot
for(int i=0; i < valuations.length; i++){
myBids = myBids + (r.nextDouble()*10);//random bid 0 to 10
if(i < valuations.length-1)
myBids = myBids + " ";//separate bids with a space! IMPORTANT!
}
*/
// EDIT HERE!
HashMap<Integer, Double> a_bids = agent.getBids();
String myBids = "";
for (int i = 0; i < valuations.length; i++) {
if (a_bids.containsKey(i)) {
myBids = myBids + a_bids.get(i);
} else {
myBids = myBids + 0.0;
}
if (i < valuations.length - 1) myBids = myBids + " ";
}
///////////////////////////////////////////////
out.println(myBids); // Send agent's bids to server
System.out.println("Mybids: " + myBids + "\n");
}
// ***********************************************************************
// Observe the state of auction variables. Store information locally
else if (fromServer.startsWith("observe-auction-state:")) {
String[] stateVars = fromServer.split("[ ]"); // tokens delimited with spaces
int numAgents = Integer.valueOf(stateVars[1]);
int numTimeSlots = Integer.valueOf(stateVars[2]);
int currentRound = Integer.valueOf(stateVars[3]); // 1st round -> 0
// currentRound is 0-indexed, so currentRound = 0 for first round
String[] leaderIDs = new String[numTimeSlots]; // leaders and their bids for each time-slot
double[] leaderBids = new double[numTimeSlots];
if (currentRound > 0) // no winners before first round
for (int i = 0; i < (numTimeSlots * 2); i += 2) { // 2 records per time slot [leader, bid]
leaderIDs[i / 2] = stateVars[4 + i];
leaderBids[i / 2] = Double.valueOf(stateVars[5 + i]);
}
System.out.println(
"Observing state:\nNumber of agents = "
+ numAgents
+ "\nNumber of time slots = "
+ numTimeSlots);
System.out.println("Current auction state:");
for (int i = 0; i < leaderIDs.length; i++)
System.out.println(
"Time-Slot "
+ i
+ ": current-leader: "
+ leaderIDs[i]
+ ", current bid = "
+ leaderBids[i]);
///////////////////////////////////////////////
// YOUR CODE HERE
// You may want to record some of the state
// information here, especially the IDs of
// current auction leaders for each time-slot
// as well as the current leading bids.
///////////////////////////////////////////////
// EDIT HERE
///////////////////////////////////////////////
out.println("State Observed"); // let the server know client received state info
System.out.println(""); // helps separate the output
}
// ***********************************************************************
else if (fromServer.startsWith("observe-final-outcome:")) {
// fromServer = "observe-final-outcome: winnerID_0 price_0 winnerID_1 price_1 ..."
String[] outcomeVars = fromServer.split("[ ]"); // tokens delimited with spaces
// for each slot, announce winner's ID and their price
for (int i = 1; i < outcomeVars.length; i += 2) {
String winnerID = outcomeVars[i];
double winPrice = Double.valueOf(outcomeVars[i + 1]);
System.out.println(
"Time Slot "
+ ((i + 1) / 2)
+ " awarded to ["
+ winnerID
+ "] for price = "
+ winPrice);
}
out.println("Final Outcome Observed"); // let the server know client received state info
}
// ***********************************************************************
// The server says to end the connection
else if (fromServer.equals("END")) {
System.out.println("END called. closing");
break;
}
// ***********************************************************************
else System.out.println("Unexpected input: " + fromServer);
}
out.close();
in.close();
stdIn.close();
auctSocket.close();
}
/** Loads the lexicon and morph files. */
public void init(URL lexiconUrl, URL morphUrl) throws IOException {
List<Family> lexicon = null;
List<MorphItem> morph = null;
List<MacroItem> macroModel = null;
// load category families (lexicon), morph forms and macros
lexicon = getLexicon(lexiconUrl);
Pair<List<MorphItem>, List<MacroItem>> morphInfo = getMorph(morphUrl);
morph = morphInfo.a;
macroModel = morphInfo.b;
// index words; also index stems to words, as default preds
// store indexed coarticulation attrs too
_words = new GroupMap<Word, MorphItem>();
_predToWords = new GroupMap<String, Word>();
_coartAttrs = new HashSet<String>();
_indexedCoartAttrs = new HashSet<String>();
for (MorphItem morphItem : morph) {
Word surfaceWord = morphItem.getSurfaceWord();
_words.put(surfaceWord, morphItem);
_predToWords.put(morphItem.getWord().getStem(), surfaceWord);
if (morphItem.isCoart()) {
Word indexingWord = morphItem.getCoartIndexingWord();
_words.put(indexingWord, morphItem);
Pair<String, String> first = indexingWord.getSurfaceAttrValPairs().next();
_indexedCoartAttrs.add(first.a);
for (Iterator<Pair<String, String>> it = surfaceWord.getSurfaceAttrValPairs();
it.hasNext(); ) {
Pair<String, String> p = it.next();
_coartAttrs.add(p.a);
}
}
}
// index entries based on stem+pos
_stems = new GroupMap<String, Object>();
_posToEntries = new GroupMap<String, EntriesItem[]>();
// index entries by supertag+pos, for supertagging
_stagToEntries = new GroupMap<String, EntriesItem>();
// also index rels and coart rels to preds
_relsToPreds = new GroupMap<String, String>();
_coartRelsToPreds = new GroupMap<String, String>();
// and gather list of attributes used per atomic category type
_catsToAttrs = new GroupMap<String, String>();
_lfAttrs = new HashSet<String>();
// and remember family and ent, names, for checking excluded list on morph items
HashSet<String> familyAndEntryNames = new HashSet<String>();
// index each family
for (Family family : lexicon) {
familyAndEntryNames.add(family.getName());
EntriesItem[] entries = family.getEntries();
DataItem[] data = family.getData();
// for generic use when we get an unknown stem
// from the morphological analyzer
if (!family.isClosed()) {
_posToEntries.put(family.getPOS(), entries);
}
// scan through entries
for (int j = 0; j < entries.length; j++) {
// index
EntriesItem eItem = entries[j];
_stagToEntries.put(eItem.getSupertag() + family.getPOS(), eItem);
if (eItem.getStem().length() > 0) {
_stems.put(eItem.getStem() + family.getPOS(), eItem);
}
try {
// gather features
eItem.getCat().forall(gatherAttrs);
// record names
familyAndEntryNames.add(eItem.getName());
familyAndEntryNames.add(eItem.getQualifiedName());
} catch (RuntimeException exc) {
System.err.println("exception for: " + family.getName() + ": " + exc);
}
}
// scan through data
for (int j = 0; j < data.length; j++) {
DataItem dItem = data[j];
_stems.put(
dItem.getStem() + family.getPOS(), new Pair<DataItem, EntriesItem[]>(dItem, entries));
// index non-default preds to words
if (!dItem.getStem().equals(dItem.getPred())) {
Collection<Word> words = (Collection<Word>) _predToWords.get(dItem.getStem());
if (words == null) {
if (!openlex) {
System.out.print("Warning: couldn't find words for pred '");
System.out.println(dItem.getPred() + "' with stem '" + dItem.getStem() + "'");
}
} else {
for (Iterator<Word> it = words.iterator(); it.hasNext(); ) {
_predToWords.put(dItem.getPred(), it.next());
}
}
}
}
// index rels to preds
// nb: this covers relational (eg @x<GenRel>e) and featural (eg @e<tense>past)
// elementary predications
List<String> indexRels = new ArrayList<String>(3);
String familyIndexRel = family.getIndexRel();
if (familyIndexRel.length() > 0) {
indexRels.add(familyIndexRel);
}
for (int j = 0; j < entries.length; j++) {
EntriesItem eItem = entries[j];
String indexRel = eItem.getIndexRel();
if (indexRel.length() > 0 && !indexRel.equals(familyIndexRel)) {
indexRels.add(indexRel);
}
}
for (Iterator<String> it = indexRels.iterator(); it.hasNext(); ) {
String indexRel = it.next();
// nb: not indexing on entries items, b/c some stems are still defaults
for (int j = 0; j < data.length; j++) {
DataItem dItem = data[j];
_relsToPreds.put(indexRel, dItem.getPred());
}
}
// index coart rels (features, really) to preds
String coartRel = family.getCoartRel();
if (coartRel.length() > 0) {
for (int j = 0; j < data.length; j++) {
_coartRelsToPreds.put(coartRel, data[j].getPred());
}
}
}
// index the macros
_macros = new GroupMap<String, FeatureStructure>();
// nb: could just index MacroItem objects for feature structures too;
// this might be a bit cleaner, but life is short
_macroItems = new HashMap<String, MacroItem>();
for (MacroItem mi : macroModel) {
String macName = mi.getName();
FeatureStructure[] specs = mi.getFeatureStructures();
for (int j = 0; j < specs.length; j++) {
_macros.put(macName, specs[j]);
}
// this is for handling LF part of macros
_macroItems.put(macName, mi);
}
// with morph items, check POS, macro names, excluded list for xref
for (MorphItem morphItem : morph) {
Word w = morphItem.getWord();
if (!openlex
&& !_stems.containsKey(w.getStem() + w.getPOS())
&& !_posToEntries.containsKey(w.getPOS())) {
System.err.println(
"Warning: no entries for stem '"
+ w.getStem()
+ "' and POS '"
+ w.getPOS()
+ "' found for word '"
+ w
+ "'");
}
String[] macroNames = morphItem.getMacros();
for (int j = 0; j < macroNames.length; j++) {
if (!_macroItems.containsKey(macroNames[j])) {
System.err.println(
"Warning: macro "
+ macroNames[j]
+ " not found for word '"
+ morphItem.getWord()
+ "'");
}
}
String[] excludedNames = morphItem.getExcluded();
for (int j = 0; j < excludedNames.length; j++) {
if (!familyAndEntryNames.contains(excludedNames[j])) {
System.err.println(
"Warning: excluded family or entry '"
+ excludedNames[j]
+ "' not found for word '"
+ morphItem.getWord()
+ "'");
}
}
}
}
@SuppressWarnings({"unchecked", "rawtypes"})
public static void main(String[] args) throws IOException {
boolean useArguments = false;
Map config = null;
try {
yamlInstance = new Yaml();
/*
* Try to load configuration file
*/
FileReader configFile = new FileReader(YAML_PATH + CONFIGURATION_FILE);
config = (Map) yamlInstance.load(configFile);
} catch (FileNotFoundException e) {
System.out.println(
"Could not load configuration file. Using program " + "arguments instead.");
useArguments = true;
}
/* Scan for program arguments */
int port = -1;
try {
if (useArguments) port = Integer.parseInt(args[0]);
else
// take the port number from the config file
port = (Integer) config.get("port");
} catch (ArrayIndexOutOfBoundsException e) {
System.err.println("DungeonServer: specify a port to which to bind");
System.out.println(usage());
System.exit(1);
}
/* Attempt to bind to port */
ServerSocket server = null;
try {
server = new ServerSocket(port);
} catch (IOException e) {
System.err.printf("DungeonServer: could not listen on port %d\n", port);
System.exit(2);
}
System.out.printf("bound to port %d\n", port);
System.out.println("loading universe:");
/* Load universe */
try {
System.out.println("\tfinding universe file");
FileReader universeFile = null;
if (useArguments) universeFile = new FileReader(YAML_PATH + DEFAULT_UNIVERSE_FILE);
else universeFile = new FileReader(YAML_PATH + config.get("world") + ".universe.yml");
Object[] docs = new Object[3];
Map<String, Object> preamble = null;
Map<String, Map<String, Object>> rooms = null, items = null;
try {
System.out.println("\tchecking universe file");
int i = 0;
for (Object o : yamlInstance.loadAll(universeFile)) docs[i++] = o;
preamble = (Map<String, Object>) docs[0];
rooms = (Map<String, Map<String, Object>>) docs[1];
items = (Map<String, Map<String, Object>>) docs[2];
if (preamble == null || rooms == null || items == null) throw new NullPointerException();
} catch (ArrayIndexOutOfBoundsException e) {
System.err.println(
"DungeonServer: error parsing universe " + "file: too many documents in universe file");
System.exit(3);
} catch (NullPointerException e) {
System.err.println(
"DungeonServer: error parsing universe " + "file: too few documents in universe file");
System.exit(3);
}
/*
* Used after parsing rooms to set universe parameters
*/
boolean doWeather = false;
String spawnRoomID = null;
int timescale = -1;
try {
System.out.println("\treading preamble");
/*
* Load universe parameters from the preamble
*/
doWeather = (Boolean) validateAndGet(preamble, "weather", Boolean.class);
spawnRoomID = (String) validateAndGet(preamble, "spawn", String.class);
timescale = (Integer) validateAndGet(preamble, "timescale", Integer.class);
} catch (Exception e) {
System.err.println("DungeonServer: failed parsing preamble (" + e.getMessage() + ")");
System.exit(4);
}
/*
* Loop through room definitions in universe file
*/
/**
* This hash map is used to resolve references from one room to another. Each time a room is
* parsed, it is added to this map, and henceforth back references to the newly added room
* will be resolved by checking this map.
*/
HashMap<String, Room> knownRooms = new HashMap<String, Room>();
/**
* This list is maintained to easily check at the end of parsing if there are still references
* to unseen rooms.
*/
ArrayList<String> unseenRooms = new ArrayList<String>();
/**
* This is a list of triples (A, B, C) such that A is a room waiting for a reference to
* another room, C, through a direction B. For A and B, the string ID of the rooms are used
* (the same key used in the knownRooms hash map). This list is used whenever a room's exit
* references cannot actually be resolved because the destination room has not yet been
* parsed. At the end of parsing, as long as the unseenRooms list is empty, this list is
* traversed to resolve the remaining references.
*/
ArrayList<Triple<String, Direction, String>> unresolved;
unresolved = new ArrayList<Triple<String, Direction, String>>();
String thisRoomID = null;
try {
System.out.println("\tparsing rooms");
for (Map.Entry<String, Map<String, Object>> m : rooms.entrySet()) {
thisRoomID = m.getKey();
Map<String, Object> thisMap = m.getValue();
String roomName = (String) validateAndGet(thisMap, "name", String.class);
String description = (String) validateAndGet(thisMap, "description", String.class);
Hashtable<Pair<DayPart, Weather>, String> details;
details = getDetails(thisMap);
Room r = new Room(roomName, description, details);
if (thisMap.containsKey("neverUseArticle")) {
boolean neverUseArticle =
(Boolean) validateAndGet(thisMap, "neverUseArticle", Boolean.class);
r.setNeverUseArticle(neverUseArticle);
}
if (unseenRooms.contains(thisRoomID)) unseenRooms.remove(thisRoomID);
knownRooms.put(thisRoomID, r);
/*
* Process exits out of this room
*/
Map<String, String> exits = (Map) validateAndGet(thisMap, "exits", Map.class);
for (Map.Entry<String, String> exit : exits.entrySet()) {
String thisDirection = exit.getKey();
String toRoomID = exit.getValue();
/*
* Verify the direction from the file
*/
Direction dir;
dir = Direction.fromString(thisDirection);
if (dir == null) throw new InvalidDirectionException(thisDirection);
/*
* Look up the destination room in the hash map
*/
if (knownRooms.containsKey(toRoomID)) r.addExit(dir, knownRooms.get(toRoomID));
else {
if (!unseenRooms.contains(toRoomID)) unseenRooms.add(toRoomID);
Triple<String, Direction, String> t;
t = new Triple<String, Direction, String>(thisRoomID, dir, toRoomID);
unresolved.add(t);
}
}
}
} catch (Exception e) {
System.err.println(
"DungeonServer: failed parsing room '" + thisRoomID + "' (" + e.getMessage() + ")");
System.exit(4);
}
if (!unseenRooms.isEmpty()) throw new UnresolvedReferenceException(unseenRooms);
/*
* Invariant: There were no references to undefined rooms in the
* file. Invariant: All the rooms in the file have been
* instantiated.
*
* All rooms in the universe file have been parsed, but there may
* still be exits waiting to be added because their destination was
* not yet parsed at the time. Now loop through the unresolved list
* to set them up.
*/
for (Triple<String, Direction, String> t : unresolved) {
Room fromRoom = knownRooms.get(t.first);
Room toRoom = knownRooms.get(t.third);
Direction dir = t.second;
fromRoom.addExit(dir, toRoom);
}
/*
* Invariant: All exits in the file have been set up among the
* rooms.
*/
Room spawnRoom = knownRooms.get(spawnRoomID);
universe = new DungeonUniverse(spawnRoom, doWeather, timescale, knownRooms.values());
universeFile.close();
} catch (Exception e) {
System.err.println("DungeonServer: failed loading universe " + "(" + e.getMessage() + ")");
System.exit(2);
}
System.out.println("loaded universe");
/* Start narrator */
try {
narrator = new DungeonNarrator();
} catch (Exception e) {
System.err.println("DungeonServer: failed starting narrator");
System.exit(3);
}
System.out.println("started narrator");
/* Start the game tick */
try {
tick = new DungeonGameTick();
tick.start();
} catch (Exception e) {
System.err.println("DungeonServer: failed starting game tick");
System.exit(3);
}
System.out.println("started game tick");
/* Start accepting events */
try {
events = new DungeonDispatcher();
events.start();
} catch (Exception e) {
System.err.println("DungeonServer: failed starting event queue");
System.exit(3);
}
System.out.println("started event queue");
/* Listen for clients */
try {
System.out.println("listening for clients");
while (true) new DungeonConnectionThread(server.accept()).start();
} catch (IOException e) {
System.err.printf("DungeonServer: failed accepting client on port %d\n", port);
System.exit(2);
} finally {
server.close();
}
}