import eis.iilang.Action; //导入依赖的package包/类
@Override
public Document actionToXML(Action action) {

    // translate parameters to String
    List<String> parameters = new Vector<>();
    action.getParameters().forEach(param -> {
        if (param instanceof Identifier){
            parameters.add(((Identifier) param).getValue());
        }
        else if(param instanceof Numeral){
            parameters.add(((Numeral) param).getValue().toString());
        }
        else{
            log("Cannot translate parameter " + param);
            parameters.add(""); // add empty parameter so the order is not invalidated
        }
    });

    // create massim protocol action
    massim.protocol.messagecontent.Action massimAction =
            new massim.protocol.messagecontent.Action(action.getName(), parameters.toArray(new String[parameters.size()]));
    massimAction.setID(currentActionId);

    return new Message(null, massimAction).toXML();
}
 

import eis.iilang.Action; //导入依赖的package包/类
/**
 * Performs an action by transforming it to XML and sending it to the massim server.
 * @param action the action to perform
 * @throws ActException if the action could not be sent
 */
void performAction(Action action) throws ActException{

    if (!connected) throw new ActException(ActException.FAILURE, "no valid connection");

    // wait for a valid action id
    long startTime = System.currentTimeMillis();
    if (scheduling) {
        while (currentActionId <= lastUsedActionId || currentActionId == -1) {
            try { Thread.sleep(10); } catch (InterruptedException ignored) {}
            if (System.currentTimeMillis() - startTime >= timeout) {
                throw new ActException(ActException.FAILURE, "timeout. no valid action-id available in time");
            }
        }
    }

    Document doc = actionToXML(action);
    try {
        assert currentActionId != lastUsedActionId;
        sendDocument(doc);
        lastUsedActionId = currentActionId;
    } catch (TransformerException | IOException e) {
        releaseConnection();
        throw new ActException(ActException.FAILURE, "sending action failed", e);
    }
}
 

import eis.iilang.Action; //导入依赖的package包/类
@Override
protected boolean isSupportedByEntity(Action action, String entity) {

	Vector<String> actions = new Vector<String>();
	actions.add("attack");
	actions.add("buy");
	actions.add("goto");
	actions.add("inspect");
	actions.add("parry");
	actions.add("probe");
	actions.add("recharge");
	actions.add("repair");
	actions.add("skip");
	actions.add("survey");
	
	if ( actions.contains(action.getName()) ) {
		return true;
	}
	
	return false;
}
 

import eis.iilang.Action; //导入依赖的package包/类
@Override
protected Document actionToXML(Action action) {

	String actionType = null;
	actionType = action.getName();
	
	String actionParameter = null;
	if ( action.getParameters().size() != 0)
		actionParameter = action.getParameters().element().toProlog();
	
	String actionId = null;
	actionId = "" + getCurrentActionId();
	
		// create document
	Document doc = null;
	try {
		
		doc = documentbuilderfactory.newDocumentBuilder().newDocument();
		Element root = doc.createElement("message");
		root.setAttribute("type","action");
		doc.appendChild(root);
		
		Element auth = doc.createElement("action");
		auth.setAttribute("type",actionType);
		if ( actionParameter != null )
			auth.setAttribute("param",actionParameter);
		auth.setAttribute("id",actionId);
		root.appendChild(auth);
		
	} catch (ParserConfigurationException e) {
		System.err.println("unable to create new document");
		return null;
	}
	
	//System.out.println(action.toProlog());
	//System.out.println(XMLToString(doc));
	
	return doc;

}
 

import eis.iilang.Action; //导入依赖的package包/类
@Override
protected Percept performEntityAction(String entity, Action action)
		throws ActException {
	Entity e = entityNamesToObjects.get(entity);
	if ( e.isConnected() == false ) {
		//throw new ActException(ActException.FAILURE,"no valid connection");
	}
	try {
		e.performAction(action);
	} 
	catch (ActException ee) {
		throw ee;
	} 
	return new Percept("done");
}
 

import eis.iilang.Action; //导入依赖的package包/类
@Override
protected boolean isSupportedByEnvironment(Action action) {
    return action != null && supportedActions.contains( action.getName());
}
 

import eis.iilang.Action; //导入依赖的package包/类
@Override
protected boolean isSupportedByType(Action action, String type) {
    return action != null && supportedActions.contains(action.getName());
}
 

import eis.iilang.Action; //导入依赖的package包/类
@Override
protected boolean isSupportedByEntity(Action action, String entity) {
    return action != null && supportedActions.contains(action.getName());
}
 

import eis.iilang.Action; //导入依赖的package包/类
@Override
protected Percept performEntityAction(String name, Action action) throws ActException {
    EISEntity entity = entities.get(name);
    entity.performAction(action);
    return new Percept("done");
}
 

import eis.iilang.Action; //导入依赖的package包/类
@Override
protected boolean isSupportedByEntity(Action arg0, String arg1) {
    return true;
}
 

import eis.iilang.Action; //导入依赖的package包/类
@Override
protected boolean isSupportedByType(Action action, String type) {
	return true;
}
 

import eis.iilang.Action; //导入依赖的package包/类
/**
 * Performs an action. The action is fistly transformed to an XML-message.
 * Secondly it is sent off.
 * @param action
 * @throws ActException 
 */
public void performAction(Action action) throws ActException {
			
	if ( connected == false ) {
		establishConnection();
		if ( connected == false ) {
			releaseConnection();
			throw new ActException(ActException.FAILURE,"no valid connection");
		}
	}
	
	// waiting for a valid action id
	long startTime = System.currentTimeMillis();
	if ( scheduling == true ) {
		while ( currentActionId <= lastUsedActionId || currentActionId == -1 ) {
			//System.out.println("waiting for valid id. last=" + lastUsedActionId + " current=" + currentActionId);
			try { Thread.sleep(10); } catch (InterruptedException e) {}
			long diff = System.currentTimeMillis() - startTime;
			if ( diff >= timeout ) {
				//releaseConnection();
				throw new ActException(ActException.FAILURE,"timeout. no valid action-id available in time");
			}
		}
	}
	
	
	//
	Document doc = null;
	doc = actionToXML(action);

	// send
	try {
		assert currentActionId != lastUsedActionId;
		//println("using action id " + currentActionId);
		sendDocument(doc);
		lastUsedActionId = currentActionId;
	} catch (IOException e) {
		//e.printStackTrace();
		// TODO some text
		//System.out.println("connection lost");
		//connected = false;
		releaseConnection();
		throw new ActException(ActException.FAILURE,"sending failed action",e);
	}

	//println("sent");
	if(statsActivated)
		stats.submitAction(name, currentActionId, action.getName(), startTime);
}
 

import eis.iilang.Action; //导入依赖的package包/类
public static Action literalToAction(Literal action) {
    Parameter[] pars = new Parameter[action.getArity()];
    for (int i=0; i<action.getArity(); i++)
        pars[i] = termToParameter(action.getTerm(i));            
    return new Action(action.getFunctor(), pars);
}
 

import eis.iilang.Action; //导入依赖的package包/类
public static Structure actoinToStructure(Action action) throws JasonException {
    Structure s = ASSyntax.createStructure(action.getName());
    for (Parameter par: action.getParameters())
        s.addTerm(parameterToTerm(par));
    return s;
}
 

import eis.iilang.Action; //导入依赖的package包/类
@Override
protected boolean isSupportedByEnvironment(Action action) {
	return true;
}