void FORTE_INSYS_OUTPUT::executeEvent(int pa_nEIID){
switch(pa_nEIID){
case scm_nEventINITID:
output = std::make_unique<OutputSetterControl>(factory->getOutputSetter());
if(output) {
setInitialised();
SUCCESS() = output->isControlStatusOK();
RESPONSE().fromString(output->getControlStatusMessage().c_str());
} else {
resetInitialised();
SUCCESS() = false;
RESPONSE().fromString("ERROR: initialisation failed");
}
sendOutputEvent(scm_nEventINITOID);
break;
case scm_nEventREQID:
if(!QI()) {
SUCCESS() = false;
RESPONSE().fromString("QI is false");
sendOutputEvent(scm_nEventCNFID);
return;
}
if(!isInitialised()) {
SUCCESS() = false;
RESPONSE().fromString("ERROR: Not initialised");
return;
}
std::string outputName;
outputName = OUTPUT().getValue();
output->setOutputName(outputName);
output->setOutputState(CHANGE().getValue());
SUCCESS() = output->isControlStatusOK();
RESPONSE().fromString(output->getControlStatusMessage().c_str());
sendOutputEvent(scm_nEventCNFID);
}
}
static int dbCount(char * varName, response *res, error *err) {
fetchResults *fResults;
if (obtainResults(varName, &fResults, err)) {
goto exit;
}
int nResults = fResults->nResultEntries;
if (nResults == 0) {
ERROR(err, E_VAREMT);
goto exit;
}
int resultBytes = sizeof(int);
int *count = (int *) malloc(resultBytes);
if (count == NULL) {
ERROR(err, E_NOMEM);
goto exit;
}
*count = nResults;
RESPONSE(res, "Maximum result:", resultBytes, count);
return 0;
exit:
return 1;
}
static int dbAverage(char * varName, response *res, error *err) {
fetchResults *fResults;
if (obtainResults(varName, &fResults, err)) {
goto exit;
}
int nResults = fResults->nResultEntries;
if (nResults == 0) {
ERROR(err, E_VAREMT);
goto exit;
}
int resultBytes = sizeof(int);
int *average = (int *) malloc(resultBytes);
if (average == NULL) {
ERROR(err, E_NOMEM);
goto exit;
}
*average = 0;
for (int i = 0; i < nResults; i++) {
*average += fResults->results[i];
}
*average /= nResults;
RESPONSE(res, "Maximum result:", resultBytes, average);
return 0;
exit:
return 1;
}
static int dbMaximum(char * varName, response *res, error *err) {
fetchResults *fResults;
if (obtainResults(varName, &fResults, err)) {
goto exit;
}
int nResults = fResults->nResultEntries;
if (nResults == 0) {
ERROR(err, E_VAREMT);
goto exit;
}
int resultBytes = sizeof(int);
int *maximum = (int *) malloc(resultBytes);
if (maximum == NULL) {
ERROR(err, E_NOMEM);
goto exit;
}
*maximum = fResults->results[0];
for (int i = 1; i < nResults; i++) {
if (fResults->results[i] > *maximum) {
*maximum = fResults->results[i];
}
}
RESPONSE(res, "Maximum result:", resultBytes, maximum);
return 0;
exit:
return 1;
}
static int dbPrintVar(char *varName, response *res, error *err) {
if (varName == NULL) {
ERROR(err, E_BADARG);
goto exit;
}
void *payload;
VAR_TYPE type;
if (varMapGetVar(varName, &type, &payload, err)) {
goto exit;
}
int resultBytes;
int *results;
if (type == VAR_BMP) {
struct bitmap *bmp = (struct bitmap *) payload;
printf("Bitmap result: \n");
bitmapPrint(bmp);
int bmpSize = bitmapSize(bmp);
resultBytes = bmpSize * sizeof(int);
results = (int *) malloc(resultBytes);
if (resultBytes == 0) {
free(results);
results = NULL;
} else {
for (int i = 0; i < bmpSize; i++) {
results[i] = bitmapIsSet(bmp, i) ? 1 : 0;
}
}
} else if (type == VAR_RESULTS) {
fetchResults *fResults = (fetchResults *) payload;
resultBytes = fResults->nResultEntries * sizeof(int);
results = (int *) malloc(resultBytes);
memcpy(results, fResults->results, resultBytes);
if (resultBytes == 0) {
free(results);
results = NULL;
}
} else {
ERROR(err, E_VARTYPE);
goto exit;
}
RESPONSE(res, "Print var results:", resultBytes, results);
return 0;
exit:
return 1;
}
/*--------------------------------------------------------------------------------*/
BiQuadCoeffs::RESPONSE BiQuadCoeffs::CalcResponseComplex(double f, double fs, bool usetargets) const
{
static const RESPONSE mul = 2.0 * M_PI * RESPONSE(0, 1.0); // = 2.pi.j
static const RESPONSE one(1.0); // = 1
const COEFFS& coeffs = usetargets ? targets : current;
RESPONSE z1 = exp(RESPONSE(f / fs * mul)); // z^-1
RESPONSE z2 = exp(RESPONSE(f / fs * 2.0 * mul)); // z^-2
// Calculate
//
// num0 + num1.z^-1 + num2.z^-2
// H = -----------------------------
// 1 + den1.z^-1 + den2.z^-2
return ((coeffs.num0 + coeffs.num1 * z1 + coeffs.num2 * z2) /
(one + coeffs.den1 * z1 + coeffs.den2 * z2));
}
static int dbMultiply(mathArgs *args, response *res, error *err) {
char *var1 = args->var1;
char *var2 = args->var2;
if (var1 == NULL || var2 == NULL) {
ERROR(err, E_BADARG);
goto exit;
}
fetchResults *fResults1;
fetchResults *fResults2;
if (obtainResults(var1, &fResults1, err) || obtainResults(var2, &fResults2, err)) {
goto exit;
}
int nResults1 = fResults1->nResultEntries;
int nResults2 = fResults2->nResultEntries;
if (nResults1 == 0 || nResults1 != nResults2) {
ERROR(err, E_VAREMT);
goto exit;
}
int resultBytes = nResults1 * sizeof(int);
int *results = (int *) malloc(resultBytes);
if (results == NULL) {
ERROR(err, E_NOMEM);
goto exit;
}
for (int i = 0; i < nResults1; i++) {
results[i] = fResults1->results[i] * fResults2->results[i];
}
RESPONSE(res, "Add results:", resultBytes, results);
return 0;
exit:
return 1;
}
void FORTE_MRX_INFO_LED::executeEvent(int pa_nEIID){
switch(pa_nEIID){
case scm_nEventINITID:
cliCommander = std::make_unique<CliCommanderControl>(factory->getCliCommander());
if(cliCommander) {
setInitialised();
SUCCESS() = cliCommander->isControlStatusOK();
RESPONSE().fromString(cliCommander->getControlStatusMessage().c_str());
} else {
resetInitialised();
SUCCESS() = false;
RESPONSE().fromString("ERROR: initialisation failed");
}
sendOutputEvent(scm_nEventINITOID);
break;
case scm_nEventREQID:
if(!QI()) {
SUCCESS() = false;
RESPONSE().fromString("QI is false");
sendOutputEvent(scm_nEventCNFID);
return;
}
if(!isInitialised()) {
SUCCESS() = false;
RESPONSE().fromString("ERROR: Not initialised");
sendOutputEvent(scm_nEventCNFID);
return;
}
const std::string mode(MODE().getValue());
if(mode != "on" && mode != "off" && mode != "flash") {
SUCCESS() = false;
RESPONSE().fromString("ERROR: Invalid mode");
sendOutputEvent(scm_nEventCNFID);
return;
}
std::string cliCommand = "help.debug.info_led.info_led=";
cliCommand.append(MODE().getValue());
cliCommander->sendCliCommand(cliCommand);
if(!cliCommander->isControlStatusOK()) {
SUCCESS() = cliCommander->isControlStatusOK();
RESPONSE().fromString(cliCommander->getControlStatusMessage().c_str());
sendOutputEvent(scm_nEventCNFID);
return;
}
cliCommand = "help.debug.info_led.submit";
cliCommander->sendCliCommand(cliCommand);
SUCCESS() = cliCommander->isControlStatusOK();
RESPONSE().fromString(cliCommander->getControlStatusMessage().c_str());
sendOutputEvent(scm_nEventCNFID);
break;
}
}
#define RESPONSE(b) {"", 0, b, sizeof(b) - 1}
#define FAST_RESPONSE(b) {NULL, -1, b, sizeof(b) - 1}
#define FAST_SEND(b) {(const char *) 1, -2, b, sizeof(b) - 1}
#define FAST_SEND_TCF(b) {(const char *) 2, -2, b, sizeof(b) - 1}
static const struct command_response_s fax_send_test_seq[] =
{
EXCHANGE("ATE0\r", "ATE0\r\r\nOK\r\n"),
EXCHANGE("AT+FCLASS=1\r", "\r\nOK\r\n"),
EXCHANGE("ATD123456789\r", "\r\nCONNECT\r\n"),
//<NSF frame> AT+FRH=3 is implied when dialing in the AT+FCLASS=1 state
//RESPONSE("\xFF\x03\x10\x03"),
//RESPONSE("\r\nOK\r\n"),
//EXCHANGE("AT+FRH=3\r", "\r\nCONNECT\r\n"),
//<CSI frame data>
RESPONSE("\xFF\x03\x40\x31\x31\x31\x31\x31\x31\x31\x31\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x1e\x46\x10\x03"),
RESPONSE("\r\nOK\r\n"),
EXCHANGE("AT+FRH=3\r", "\r\nCONNECT\r\n"),
//<DIS frame data>
RESPONSE("\xFF\x13\x80\x00\xEE\xF8\x80\x80\x91\x80\x80\x80\x18\x78\x57\x10\x03"), // For audio FAXing
//RESPONSE("\xFF\x13\x80\x04\xEE\xF8\x80\x80\x91\x80\x80\x80\x18\xE4\xE7\x10\x03"), // For T.38 FAXing
RESPONSE("\r\nOK\r\n"),
//EXCHANGE("AT+FRH=3\r", "\r\nNO CARRIER\r\n"),
EXCHANGE("AT+FTH=3\r", "\r\nCONNECT\r\n"),
//<TSI frame data>
EXCHANGE("\xFF\x03\x43\x32\x32\x32\x32\x32\x32\x32\x32\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x10\x03", "\r\nCONNECT\r\n"),
//<DCS frame data>
EXCHANGE("\xFF\x13\x83\x01\xC6\x80\x80\x80\x80\x01\xFD\x13\x10\x03", "\r\nOK\r\n"),
//Do a wait for timed silence at this point, or there won't be one in the tests
EXCHANGE("AT+FRS=7\r", "\r\nOK\r\n"),
//EXCHANGE("AT+FTS=8;+FTM=96\r", "\r\nCONNECT\r\n"),
char type;
int bell_volume;
int keyclick_volume;
int ctrlclick_volume;
};
#ifdef LKKBD_DEBUG
/*
* Responses from the keyboard and mapping back to their names.
*/
static struct {
unsigned char value;
unsigned char *name;
} lk_response[] = {
#define RESPONSE(x) { .value = (x), .name = #x, }
RESPONSE (LK_STUCK_KEY),
RESPONSE (LK_SELFTEST_FAILED),
RESPONSE (LK_ALL_KEYS_UP),
RESPONSE (LK_METRONOME),
RESPONSE (LK_OUTPUT_ERROR),
RESPONSE (LK_INPUT_ERROR),
RESPONSE (LK_KBD_LOCKED),
RESPONSE (LK_KBD_TEST_MODE_ACK),
RESPONSE (LK_PREFIX_KEY_DOWN),
RESPONSE (LK_MODE_CHANGE_ACK),
RESPONSE (LK_RESPONSE_RESERVED),
#undef RESPONSE
};
static unsigned char *
response_name (unsigned char value)
static int dbFetch(tableInfo *tbl, fetchArgs *args, response *res, error *err) {
char *columnName = args->columnName;
char *oldVarName = args->oldVarName;
char *newVarName = args->newVarName;
if (columnName == NULL || oldVarName == NULL) {
ERROR(err, E_BADARG);
goto exit;
}
printf("Fetching from column '%s'...\n", columnName);
// Get bitmap from var name
struct bitmap *bmp;
VAR_TYPE type;
if (varMapGetVar(oldVarName, &type, (void **) (&bmp), err)) {
goto exit;
}
if (type != VAR_BMP) {
ERROR(err, E_VARTYPE);
goto exit;
}
printf("Got bitmap for variable '%s'\n", oldVarName);
bitmapPrint(bmp);
// Retrieve the column from disk
column *col = (column *) malloc(sizeof(column));
if (col == NULL) {
ERROR(err, E_NOMEM);
goto exit;
}
if (columnReadFromDisk(tbl, columnName, col, err)) {
free(col);
goto exit;
}
// Fetch the results
int resultBytes;
int *results;
int *indices;
if (columnFetch(col, bmp, &resultBytes, &results, &indices, err)) {
goto cleanupColumn;
}
// Return data to user if the haven't given a variable to store it in
if (newVarName[0] == '\0') {
int nResults = resultBytes / sizeof(int);
printf("Got %d results from fetch\n", nResults);
printf("[");
for (int i = 0; i < nResults; i++) {
printf("%d,", results[i]);
}
printf("]\n");
if (resultBytes == 0) {
results = NULL;
}
RESPONSE(res, "Fetch results:", resultBytes, results);
free(indices);
}
// Otherwise, store data in variable
else {
// Add variable-results pair to varmap
fetchResults *fResults = (fetchResults *) malloc(sizeof(fetchResults));
if (fResults == NULL) {
ERROR(err, E_NOMEM);
goto cleanupColumn;
}
fResults->nColumnEntries = bitmapSize(bmp);
fResults->nResultEntries = resultBytes / sizeof(int);
fResults->results = results;
fResults->indices = indices;
if (varMapAddVar(newVarName, VAR_RESULTS, fResults, err)) {
free(results);
free(indices);
free(fResults);
goto cleanupColumn;
}
printf("Added variable '%s'\n", newVarName);
RESPONSE_SUCCESS(res);
}
// Cleanup
columnDestroy(col);
return 0;
// cleanupResults:
// free(results);
// free(indices);
cleanupColumn:
columnDestroy(col);
exit:
return 1;
}
std::vector<talk_response> gen_responses(talk_topic topic, game *g, npc *p)
{
std::vector<talk_response> ret;
switch (topic) {
case TALK_MISSION_LIST:
if (p->chatbin.missions.empty()) {
RESPONSE(_("Oh, okay."));
SUCCESS(TALK_NONE);
} else if (p->chatbin.missions.size() == 1) {
SELECT_MISS(_("Tell me about it."), 0);
SUCCESS(TALK_MISSION_OFFER);
RESPONSE(_("Never mind, I'm not interested."));
SUCCESS(TALK_NONE);
} else {
for (int i = 0; i < p->chatbin.missions.size(); i++) {
SELECT_MISS(g->find_mission_type( p->chatbin.missions[i] )->name, i);
SUCCESS(TALK_MISSION_OFFER);
}
RESPONSE(_("Never mind, I'm not interested."));
SUCCESS(TALK_NONE);
}
break;
case TALK_MISSION_LIST_ASSIGNED:
if (p->chatbin.missions_assigned.empty()) {
RESPONSE(_("Never mind then."));
SUCCESS(TALK_NONE);
} else if (p->chatbin.missions_assigned.size() == 1) {
SELECT_MISS(_("I have news."), 0);
SUCCESS(TALK_MISSION_INQUIRE);
RESPONSE(_("Never mind."));
SUCCESS(TALK_NONE);
} else {
for (int i = 0; i < p->chatbin.missions_assigned.size(); i++) {
SELECT_MISS(g->find_mission_type( p->chatbin.missions_assigned[i] )->name,
i);
SUCCESS(TALK_MISSION_INQUIRE);
}
RESPONSE(_("Never mind."));
SUCCESS(TALK_NONE);
}
break;
case TALK_MISSION_DESCRIBE:
RESPONSE(_("What's the matter?"));
SUCCESS(TALK_MISSION_OFFER);
RESPONSE(_("I don't care."));
SUCCESS(TALK_MISSION_REJECTED);
break;
case TALK_MISSION_OFFER:
RESPONSE(_("I'll do it!"));
SUCCESS(TALK_MISSION_ACCEPTED);
SUCCESS_ACTION(&talk_function::assign_mission);
RESPONSE(_("Not interested."));
SUCCESS(TALK_MISSION_REJECTED);
break;
case TALK_MISSION_ACCEPTED:
RESPONSE(_("Not a problem."));
SUCCESS(TALK_NONE);
RESPONSE(_("Got any advice?"));
SUCCESS(TALK_MISSION_ADVICE);
RESPONSE(_("Can you share some equipment?"));
SUCCESS(TALK_SHARE_EQUIPMENT);
RESPONSE(_("I'll be back soon!"));
SUCCESS(TALK_DONE);
break;
case TALK_MISSION_ADVICE:
RESPONSE(_("Sounds good, thanks."));
SUCCESS(TALK_NONE);
RESPONSE(_("Sounds good. Bye!"));
SUCCESS(TALK_DONE);
break;
case TALK_MISSION_REJECTED:
RESPONSE(_("I'm sorry."));
SUCCESS(TALK_NONE);
RESPONSE(_("Whatever. Bye."));
SUCCESS(TALK_DONE);
break;
case TALK_MISSION_INQUIRE: {
int id = p->chatbin.missions_assigned[ p->chatbin.mission_selected ];
if (g->mission_failed(id)) {
RESPONSE(_("I'm sorry... I failed."));
SUCCESS(TALK_MISSION_FAILURE);
SUCCESS_OPINION(-1, 0, -1, 1, 0);
RESPONSE(_("Not yet."));
TRIAL(TALK_TRIAL_LIE, 10 + p->op_of_u.trust * 3);
SUCCESS(TALK_NONE);
FAILURE(TALK_MISSION_FAILURE);
FAILURE_OPINION(-3, 0, -1, 2, 0);
} else if (!g->mission_complete(id, p->id)) {
mission_type *type = g->find_mission_type(id);
RESPONSE(_("Not yet."));
SUCCESS(TALK_NONE);
if (type->goal == MGOAL_KILL_MONSTER) {
RESPONSE(_("Yup, I killed it."));
TRIAL(TALK_TRIAL_LIE, 10 + p->op_of_u.trust * 5);
SUCCESS(TALK_MISSION_SUCCESS);
SUCCESS_ACTION(&talk_function::mission_success);
FAILURE(TALK_MISSION_SUCCESS_LIE);
FAILURE_OPINION(-5, 0, -1, 5, 0);
FAILURE_ACTION(&talk_function::mission_failure);
}
RESPONSE(_("No. I'll get back to it, bye!"));
SUCCESS(TALK_DONE);
} else {
// TODO: Lie about mission
mission_type *type = g->find_mission_type(id);
switch (type->goal) {
case MGOAL_FIND_ITEM:
case MGOAL_FIND_ANY_ITEM:
RESPONSE(_("Yup! Here it is!"));
SUCCESS(TALK_MISSION_SUCCESS);
SUCCESS_ACTION(&talk_function::mission_success);
break;
case MGOAL_GO_TO:
case MGOAL_FIND_NPC:
RESPONSE(_("Here I am."));
SUCCESS(TALK_MISSION_SUCCESS);
SUCCESS_ACTION(&talk_function::mission_success);
break;
case MGOAL_FIND_MONSTER:
RESPONSE(_("Here it is!"));
SUCCESS(TALK_MISSION_SUCCESS);
SUCCESS_ACTION(&talk_function::mission_success);
break;
case MGOAL_KILL_MONSTER:
RESPONSE(_("I killed it."));
SUCCESS(TALK_MISSION_SUCCESS);
SUCCESS_ACTION(&talk_function::mission_success);
break;
default:
RESPONSE(_("Mission success! I don't know what else to say."));
SUCCESS(TALK_MISSION_SUCCESS);
SUCCESS_ACTION(&talk_function::mission_success);
break;
}
}
}
break;
case TALK_MISSION_SUCCESS:
RESPONSE(_("Glad to help. I need no payment."));
SUCCESS(TALK_NONE);
SUCCESS_OPINION(p->op_of_u.owed / (OWED_VAL * 4), -1,
p->op_of_u.owed / (OWED_VAL * 2), -1, 0 - p->op_of_u.owed);
SUCCESS_ACTION(&talk_function::clear_mission);
RESPONSE(_("How about payment?"));
SUCCESS(TALK_MISSION_REWARD);
SUCCESS_ACTION(&talk_function::mission_reward);
RESPONSE(_("Glad to help. I need no payment. Bye!"));
SUCCESS(TALK_DONE);
SUCCESS_ACTION(&talk_function::clear_mission);
SUCCESS_OPINION(p->op_of_u.owed / (OWED_VAL * 4), -1,
p->op_of_u.owed / (OWED_VAL * 2), -1, 0 - p->op_of_u.owed);
break;
case TALK_MISSION_SUCCESS_LIE:
RESPONSE(_("Well, um, sorry."));
SUCCESS(TALK_NONE);
SUCCESS_ACTION(&talk_function::clear_mission);
case TALK_MISSION_FAILURE:
RESPONSE(_("I'm sorry. I did what I could."));
SUCCESS(TALK_NONE);
break;
case TALK_MISSION_REWARD:
RESPONSE(_("Thank you."));
SUCCESS(TALK_NONE);
SUCCESS_ACTION(&talk_function::clear_mission);
RESPONSE(_("Thanks, bye."));
SUCCESS(TALK_DONE);
SUCCESS_ACTION(&talk_function::clear_mission);
break;
case TALK_SHELTER:
RESPONSE(_("What should we do now?"));
SUCCESS(TALK_SHELTER_PLANS);
RESPONSE(_("Can I do anything for you?"));
SUCCESS(TALK_MISSION_LIST);
if (!p->is_following()) {
RESPONSE(_("Want to travel with me?"));
SUCCESS(TALK_SUGGEST_FOLLOW);
}
if (p->chatbin.missions_assigned.size() == 1) {
RESPONSE(_("About that job..."));
SUCCESS(TALK_MISSION_INQUIRE);
} else if (p->chatbin.missions_assigned.size() >= 2) {
RESPONSE(_("About one of those jobs..."));
SUCCESS(TALK_MISSION_LIST_ASSIGNED);
}
RESPONSE(_("I can't leave the shelter without equipment..."));
SUCCESS(TALK_SHARE_EQUIPMENT);
RESPONSE(_("Well, bye."));
SUCCESS(TALK_DONE);
break;
case TALK_SHELTER_PLANS:
// TODO: Add "follow me"
RESPONSE(_("Hmm, okay. Bye."));
SUCCESS(TALK_DONE);
break;
case TALK_SHARE_EQUIPMENT: {
int score = p->op_of_u.trust + p->op_of_u.value * 3 +
p->personality.altruism * 2;
int missions_value = p->assigned_missions_value(g);
RESPONSE(_("Because I'm your friend!"));
TRIAL(TALK_TRIAL_PERSUADE, 10 + score);
SUCCESS(TALK_GIVE_EQUIPMENT);
SUCCESS_ACTION(&talk_function::give_equipment);
SUCCESS_OPINION(0, 0, -1, 0, score * 300);
FAILURE(TALK_DENY_EQUIPMENT);
FAILURE_OPINION(0, 0, -1, 0, 0);
if (missions_value >= 1) {
RESPONSE(_("Well, I am helping you out..."));
TRIAL(TALK_TRIAL_PERSUADE, 10 + score + p->op_of_u.owed / OWED_VAL);
SUCCESS(TALK_GIVE_EQUIPMENT);
SUCCESS_ACTION(&talk_function::give_equipment);
FAILURE(TALK_DENY_EQUIPMENT);
FAILURE_OPINION(0, 0, -1, 0, 0);
}
RESPONSE(_("I'll give it back!"));
TRIAL(TALK_TRIAL_LIE, score * 1.5);
SUCCESS(TALK_GIVE_EQUIPMENT);
SUCCESS_ACTION(&talk_function::give_equipment);
SUCCESS_OPINION(0, 0, -1, 0, score * 300);
FAILURE(TALK_DENY_EQUIPMENT);
FAILURE_OPINION(0, -1, -1, 1, 0);
RESPONSE(_("Give it to me, or else!"));
TRIAL(TALK_TRIAL_INTIMIDATE, 40);
SUCCESS(TALK_GIVE_EQUIPMENT);
SUCCESS_ACTION(&talk_function::give_equipment);
SUCCESS_OPINION(-3, 2, -2, 2,
(g->u.intimidation() + p->op_of_u.fear -
p->personality.bravery - p->intimidation()) * 500);
FAILURE(TALK_DENY_EQUIPMENT);
FAILURE_OPINION(-3, 1, -3, 5, 0);
RESPONSE(_("Eh, never mind."));
SUCCESS(TALK_NONE);
RESPONSE(_("Never mind, I'll do without. Bye."));
SUCCESS(TALK_DONE);
}
break;
case TALK_GIVE_EQUIPMENT:
RESPONSE(_("Thank you!"));
SUCCESS(TALK_NONE);
RESPONSE(_("Thanks! But can I have some more?"));
SUCCESS(TALK_SHARE_EQUIPMENT);
RESPONSE(_("Thanks, see you later!"));
SUCCESS(TALK_DONE);
break;
case TALK_DENY_EQUIPMENT:
RESPONSE(_("Okay, okay, sorry."));
SUCCESS(TALK_NONE);
RESPONSE(_("Seriously, give me more stuff!"));
SUCCESS(TALK_SHARE_EQUIPMENT);
RESPONSE(_("Okay, fine, bye."));
SUCCESS(TALK_DONE);
break;
case TALK_SUGGEST_FOLLOW:
if (p->has_disease(DI_INFECTION)) {
RESPONSE(_("Understood. I'll get those antibiotics."));
SUCCESS(TALK_NONE);
} else if (p->has_disease(DI_ASKED_TO_FOLLOW)) {
RESPONSE(_("Right, right, I'll ask later."));
SUCCESS(TALK_NONE);
} else {
int strength = 3 * p->op_of_u.fear + p->op_of_u.value + p->op_of_u.trust +
(10 - p->personality.bravery);
int weakness = 3 * p->personality.altruism + p->personality.bravery -
p->op_of_u.fear + p->op_of_u.value;
int friends = 2 * p->op_of_u.trust + 2 * p->op_of_u.value -
2 * p->op_of_u.anger + p->op_of_u.owed / 50;
RESPONSE(_("I can keep you safe."));
TRIAL(TALK_TRIAL_PERSUADE, strength * 2);
SUCCESS(TALK_AGREE_FOLLOW);
SUCCESS_ACTION(&talk_function::follow);
SUCCESS_OPINION(1, 0, 1, 0, 0);
FAILURE(TALK_DENY_FOLLOW);
FAILURE_ACTION(&talk_function::deny_follow);
FAILURE_OPINION(0, 0, -1, 1, 0);
RESPONSE(_("You can keep me safe."));
TRIAL(TALK_TRIAL_PERSUADE, weakness * 2);
SUCCESS(TALK_AGREE_FOLLOW);
SUCCESS_ACTION(&talk_function::follow);
SUCCESS_OPINION(0, 0, -1, 0, 0);
FAILURE(TALK_DENY_FOLLOW);
FAILURE_ACTION(&talk_function::deny_follow);
FAILURE_OPINION(0, -1, -1, 1, 0);
RESPONSE(_("We're friends, aren't we?"));
TRIAL(TALK_TRIAL_PERSUADE, friends * 1.5);
SUCCESS(TALK_AGREE_FOLLOW);
SUCCESS_ACTION(&talk_function::follow);
SUCCESS_OPINION(2, 0, 0, -1, 0);
FAILURE(TALK_DENY_FOLLOW);
FAILURE_ACTION(&talk_function::deny_follow);
FAILURE_OPINION(-1, -2, -1, 1, 0);
RESPONSE(_("!I'll kill you if you don't."));
TRIAL(TALK_TRIAL_INTIMIDATE, strength * 2);
SUCCESS(TALK_AGREE_FOLLOW);
SUCCESS_ACTION(&talk_function::follow);
SUCCESS_OPINION(-4, 3, -1, 4, 0);
FAILURE(TALK_DENY_FOLLOW);
FAILURE_OPINION(-4, 0, -5, 10, 0);
}
break;
case TALK_AGREE_FOLLOW:
RESPONSE(_("Awesome!"));
SUCCESS(TALK_NONE);
RESPONSE(_("Okay, let's go!"));
SUCCESS(TALK_DONE);
break;
case TALK_DENY_FOLLOW:
RESPONSE(_("Oh, okay."));
SUCCESS(TALK_NONE);
break;
case TALK_FRIEND:
RESPONSE(_("Combat commands..."));
SUCCESS(TALK_COMBAT_COMMANDS);
RESPONSE(_("Can I do anything for you?"));
SUCCESS(TALK_MISSION_LIST);
RESPONSE(_("Let's trade items."));
SUCCESS(TALK_NONE);
SUCCESS_ACTION(&talk_function::start_trade);
RESPONSE(_("Let's go."));
SUCCESS(TALK_DONE);
break;
case TALK_COMBAT_COMMANDS: {
RESPONSE(_("Change your engagement rules..."));
SUCCESS(TALK_COMBAT_ENGAGEMENT);
if (p->combat_rules.use_guns) {
RESPONSE(_("Don't use guns anymore."));
SUCCESS(TALK_COMBAT_COMMANDS);
SUCCESS_ACTION(&talk_function::toggle_use_guns);
} else {
RESPONSE(_("You can use guns."));
SUCCESS(TALK_COMBAT_COMMANDS);
SUCCESS_ACTION(&talk_function::toggle_use_guns);
}
if (p->combat_rules.use_grenades) {
RESPONSE(_("Don't use grenades anymore."));
SUCCESS(TALK_COMBAT_COMMANDS);
SUCCESS_ACTION(&talk_function::toggle_use_grenades);
} else {
RESPONSE(_("You can use grenades."));
SUCCESS(TALK_COMBAT_COMMANDS);
SUCCESS_ACTION(&talk_function::toggle_use_grenades);
}
RESPONSE(_("Never mind."));
SUCCESS(TALK_NONE);
}
break;
case TALK_COMBAT_ENGAGEMENT: {
if (p->combat_rules.engagement != ENGAGE_NONE) {
RESPONSE(_("Don't fight unless your life depends on it."));
SUCCESS(TALK_NONE);
SUCCESS_ACTION(&talk_function::set_engagement_none);
}
if (p->combat_rules.engagement != ENGAGE_CLOSE) {
RESPONSE(_("Attack enemies that get too close."));
SUCCESS(TALK_NONE);
SUCCESS_ACTION(&talk_function::set_engagement_close);
}
if (p->combat_rules.engagement != ENGAGE_WEAK) {
RESPONSE(_("Attack enemies that you can kill easily."));
SUCCESS(TALK_NONE);
SUCCESS_ACTION(&talk_function::set_engagement_weak);
}
if (p->combat_rules.engagement != ENGAGE_HIT) {
RESPONSE(_("Attack only enemies that I attack first."));
SUCCESS(TALK_NONE);
SUCCESS_ACTION(&talk_function::set_engagement_hit);
}
if (p->combat_rules.engagement != ENGAGE_ALL) {
RESPONSE(_("Attack anything you want."));
SUCCESS(TALK_NONE);
SUCCESS_ACTION(&talk_function::set_engagement_all);
}
RESPONSE(_("Never mind."));
SUCCESS(TALK_NONE);
}
break;
case TALK_SIZE_UP:
case TALK_LOOK_AT:
case TALK_OPINION:
RESPONSE(_("Okay."));
SUCCESS(TALK_NONE);
break;
}
if (ret.empty()) {
RESPONSE(_("Bye."));
SUCCESS(TALK_DONE);
}
return ret;
}
uchar usbFunctionWrite(uchar *data, uchar len)
{
uchar i;
uchar counter;
uint8_t temp;
if(len > bytesRemaining) // if this is the last incomplete chunk
len = bytesRemaining; // limit to the amount we can store
bytesRemaining -= len;
for(i = 0; i < len; i++)
buffer[currentPosition++] = data[i];
if(bytesRemaining == 0) {
switch(buffer[0]) {
case CMD_READ_EEDATA:
RESPONSE(read_eedata)->addr = REQUEST(read_eedata)->addr;
RESPONSE(read_eedata)->value = eeprom_read_byte((uint8_t*)(uint16_t)REQUEST(read_eedata)->addr);
buffer_len = sizeof(usb_response_read_eedata_t);
break;
case CMD_WRITE_EEDATA:
RESPONSE(write_eedata)->result = 1;
eeprom_write_byte((uint8_t*)(uint16_t)REQUEST(write_eedata)->addr, REQUEST(write_eedata)->value);
buffer_len = sizeof(usb_response_write_eedata_t);
break;
case CMD_READ_VERSION:
RESPONSE(read_version)->version_major = FIRMWARE_MAJOR;
RESPONSE(read_version)->version_minor = FIRMWARE_MINOR;
buffer_len = sizeof(usb_response_read_version_t);;
break;
case CMD_BOARD_TYPE:
RESPONSE(board_type)->board_type = BOARD_TYPE_I2C;
temp = eeprom_read_byte((uint8_t*)1);
if((temp == 0) || (temp == 255))
temp = 9;
RESPONSE(board_type)->serial = temp; // read from EEPROM address 1
#ifdef __AVR_ATmega88__
RESPONSE(board_type)->proc_type = PROCESSOR_TYPE_A88;
#elif defined __AVR_ATmega168__
RESPONSE(board_type)->proc_type = PROCESSOR_TYPE_A168;
#else
#warn "UNKNOWN PROC TYPE!"
RESPONSE(board_type)->proc_type = PROCESSOR_TYPE_UNKNOWN;
#endif
RESPONSE(board_type)->mhz = F_CPU/1000000;
buffer_len = sizeof(usb_response_board_type_t);
break;
case CMD_BD_POWER_STATE:
buffer_len = 0;
break;
case CMD_BD_POWER_INFO:
buffer_len = 0;
break;
case CMD_I2C_READ:
counter = REQUEST(i2c_read)->read_len;
RESPONSE(i2c_read)->result = counter;
buffer_len = REQUEST(i2c_read)->read_len + 1;
if((i2cMasterSendNI(REQUEST(i2c_read)->device << 1, 1, &(REQUEST(i2c_read)->address)) == I2C_OK) &&
(i2cMasterReceiveNI(REQUEST(i2c_read)->device << 1, counter, (u08*)&(RESPONSE(i2c_read)->data)) == I2C_OK)) {
RESPONSE(i2c_read)->result = 1;
} else {
RESPONSE(i2c_read)->result = 0;
*RESPONSE(i2c_read)->data = I2C_E_NODEV;
}
break;
case CMD_I2C_WRITE:
buffer_len = sizeof(usb_response_i2c_write_t);
counter = REQUEST(i2c_write)->len - 2;
RESPONSE(i2c_write)->result = counter;
if(i2cMasterSendNI(REQUEST(i2c_write)->device << 1, counter + 1, &(REQUEST(i2c_write)->address)) == I2C_OK) {
RESPONSE(i2c_write)->result = 1;
} else {
RESPONSE(i2c_write)->result = 0;
RESPONSE(i2c_write)->extended_result = I2C_E_NODEV;
}
break;
case CMD_RESET:
break;
}
}
return bytesRemaining == 0; // return 1 if we have all data
}
#define EXCHANGE(a,b) {a, sizeof(a) - 1, b, sizeof(b) - 1}
#define RESPONSE(b) {"", 0, b, sizeof(b) - 1}
#define FAST_RESPONSE(b) {NULL, -1, b, sizeof(b) - 1}
#define FAST_SEND(b) {(const char *) 1, -2, b, sizeof(b) - 1}
static const struct command_response_s fax_send_test_seq[] =
{
EXCHANGE("ATE0\r", "ATE0\r\r\nOK\r\n"),
EXCHANGE("AT+FCLASS=1\r", "\r\nOK\r\n"),
EXCHANGE("ATD123456789\r", "\r\nCONNECT\r\n"),
//<NSF frame> AT+FRH=3 is implied when dialing in the AT+FCLASS=1 state
//RESPONSE("\xFF\x03\x10\x03"),
//RESPONSE("\r\nOK\r\n"),
//EXCHANGE("AT+FRH=3\r", "\r\nCONNECT\r\n"),
//<CSI frame data>
RESPONSE("\xFF\x03\x40\x31\x31\x31\x31\x31\x31\x31\x31\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x1e\x46\x10\x03"),
RESPONSE("\r\nOK\r\n"),
EXCHANGE("AT+FRH=3\r", "\r\nCONNECT\r\n"),
//<DIS frame data>
RESPONSE("\xFF\x13\x80\x00\xEE\xF8\x80\x80\x89\x80\x80\x80\x18\x18\xB9\x10\x03"),
RESPONSE("\r\nOK\r\n"),
//EXCHANGE("AT+FRH=3\r", "\r\nNO CARRIER\r\n"),
EXCHANGE("AT+FTH=3\r", "\r\nCONNECT\r\n"),
//<TSI frame data>
EXCHANGE("\xFF\x03\x43\x32\x32\x32\x32\x32\x32\x32\x32\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x10\x03", "\r\nCONNECT\r\n"),
//<DCS frame data>
EXCHANGE("\xFF\x13\x83\x01\xC6\x80\x80\x80\x80\x01\xFD\x13\x10\x03", "\r\nOK\r\n"),
//Do a wait for timed silence at this point, or there won't be one in the tests
EXCHANGE("AT+FRS=7\r", "\r\nOK\r\n"),
//EXCHANGE("AT+FTS=8;+FTM=96\r", "\r\nCONNECT\r\n"),
EXCHANGE("AT+FTS=8\r", "\r\nOK\r\n"),
