int main(void)
{
printf("%f\n", strToFloat("1.2"));
printf("%f\n", strToFloat("24.5"));
printf("%f\n", strToFloat("-2.45"));
printf("%f\n", strToFloat("2.4.5"));
return 0;
}
int main (void)
{
printf("Number %s is %.4f.\n", "1827.4214", strToFloat("1827.4214"));
printf("Number %s is %.4f.\n", "3812,0024", strToFloat("3812,0024"));
printf("Number %s is %.4f.\n", "0.4214", strToFloat("0.4214"));
printf("Number %s is %.4f.\n", "-2783.3911", strToFloat("-2783.3911"));
return 0;
}
//takes an XML element definition and creates an object from it
GuiComponent* ThemeComponent::createElement(pugi::xml_node data, GuiComponent* parent)
{
std::string type = data.child("type").text().get();
if(type == "image")
{
std::string path = expandPath(data.child("path").text().get());
if(!boost::filesystem::exists(path))
{
LOG(LogError) << "Error - theme image \"" << path << "\" does not exist.";
return NULL;
}
std::string pos = data.child("pos").text().get();
std::string dim = data.child("dim").text().get();
std::string origin = data.child("origin").text().get();
bool tiled = data.child("tiled") != 0;
//split position and dimension information
std::string posX, posY;
splitString(pos, ' ', &posX, &posY);
std::string dimW, dimH;
splitString(dim, ' ', &dimW, &dimH);
std::string originX, originY;
splitString(origin, ' ', &originX, &originY);
//resolve to pixels from percentages/variables
int x = (int)(resolveExp(posX) * Renderer::getScreenWidth());
int y = (int)(resolveExp(posY) * Renderer::getScreenHeight());
int w = (int)(resolveExp(dimW) * Renderer::getScreenWidth());
int h = (int)(resolveExp(dimH) * Renderer::getScreenHeight());
float ox = strToFloat(originX);
float oy = strToFloat(originY);
ImageComponent* comp = new ImageComponent(mWindow, x, y, "", w, h, true);
comp->setOrigin(ox, oy);
comp->setTiling(tiled);
comp->setImage(path);
addChild(comp);
return comp;
}
LOG(LogError) << "Theme component type \"" << type << "\" unknown!";
return NULL;
}
/**
* Convert parameter to float (32 bit)
* @param context
* @param parameter
* @param value result
* @return TRUE if succesful
*/
scpi_bool_t SCPI_ParamToFloat(scpi_t * context, scpi_parameter_t * parameter, float * value) {
scpi_bool_t result;
uint32_t valint;
if (!value) {
SCPI_ErrorPush(context, SCPI_ERROR_SYSTEM_ERROR);
return FALSE;
}
switch (parameter->type) {
case SCPI_TOKEN_HEXNUM:
case SCPI_TOKEN_OCTNUM:
case SCPI_TOKEN_BINNUM:
result = SCPI_ParamToUInt32(context, parameter, &valint);
*value = valint;
break;
case SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA:
case SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA_WITH_SUFFIX:
result = strToFloat(parameter->ptr, value) > 0 ? TRUE : FALSE;
break;
default:
result = FALSE;
}
return result;
}
// Get Widget data as an float (entry, textview)
bool
GtkAReViWidget::getWidgetFloat(const StlString &propName,float &propValueOut)
{
StlString strValue;
if (!getWidgetString(propName,strValue))
return false;
return strToFloat(propValueOut,strValue);
}
float ofxArgs::getFloat(string key){
map<string,string>::iterator it;
it = this->opts.find(key);
if(it != this->opts.end()){
return strToFloat(it->second);
}
return 0.0f;
}
float getFloatOrientation(void){
float res;
if(coordValid()){
res = strToFloat(gps_CourseOverGround,16);
while(res<0)
res += 360;
}
else
res = 0;
return res;
}
char* getSpeed(void){
int i = 0;
float tconv;
if(coordValid()){
tconv = strToFloat(gps_SpeedOverGround,16);
tconv = tconv * 1.852;
i = floatToStr(tconv,temp+i,10,1);
temp[i++] = ' ';
temp[i++] = 'k';
temp[i++] = 'm';
temp[i++] = '/';
temp[i++] = 'h';
}
while(i<10)
temp[i++] = ' ';
temp[i] = 0;
return temp;
}
Font* ThemeComponent::resolveFont(pugi::xml_node node, std::string defaultPath, unsigned int defaultSize)
{
if(!node)
return NULL;
std::string path = expandPath(node.child("path").text().get());
unsigned int size = (unsigned int)(strToFloat(node.child("size").text().get()) * Renderer::getScreenHeight());
if(!boost::filesystem::exists(path))
{
path = defaultPath;
}
if(size == 0)
{
size = defaultSize;
}
return new Font(path, size);
}
void TForm1::ShowPrice()
{
float price = 0.0;
float rate = 0.0;
float fright = 0.0;
float profit = 0.0;
float freeFright, weight, no = 0.0;
price = strToFloat(txtPrice->Text);
rate = strToFloat(txtRate->Text);
fright = strToFloat(txtFright->Text);
profit = strToFloat(txtProfit->Text);
freeFright = strToFloat(txtFreeProfit->Text);
weight = strToFloat(txtWeight->Text);
if(chkNo->Checked)
{
no = strToFloat(txtNo->Text); // 挂号费
}
if(price<0.1)
{
//Application->MessageBox("请输入正确的价格！","注意", MB_ICONWARNING);
lbPrice->Caption = "请输入正确的价格！";
return;
}
float cost , sellPrice, packetFright;
cost = (price + fright)/rate;
packetFright = (weight*freeFright+no)/rate;
sellPrice = (cost + cost*profit/100 + packetFright)/0.95;
char tip[512]={0};
sprintf(tip, "成本：$%.2f \t(%.2f元)\n\
运费：$%.2f \t(%.2f元)\n\
售价：$%.2f \t(%.2f元)\n\
利润：$%.2f \t(%.2f元)",
cost, cost*rate,
packetFright, packetFright*rate,
sellPrice, sellPrice*rate,
cost*profit/100, cost*profit*rate/100
);
lbPrice->Caption = tip;
}
static uint32 createFCol(redisClient *c,
char *start,
uint32 len,
float *col) {
return strToFloat(c, start, len, col);
}
float ofxArgs::getFloat(int index){
if(index < this->argc){
return strToFloat(this->args[index]);
}
return 0.0f;
}
void mlTowersInfo::load()
{
pugi::xml_document doc; doc.load_file( "ini/towers.xml" );
pugi::xml_node root = doc.root().first_child();
_digcost = root.attribute( "digcost" ).as_int();
std::string s = root.child( "laboratory_upgrade" ).attribute( "value" ).as_string();
std::list<std::string>upgrades;
split( upgrades, s );
for( auto value : upgrades ) _labUpgrade.push_back( strToFloat( value ) );
int order( 0 );
for( auto node = root.first_child(); node; node = node.next_sibling() )
{
towerInfo info;
std::string name = node.attribute( "name" ).value();
pugi::xml_node costXml = node.child( "cost" );
pugi::xml_node costlabXml = node.child( "costlab" );
pugi::xml_node sellXml = node.child( "sell" );
pugi::xml_node levelXml = node.child( "minlevel" );
info.order = order++;
info.sellRate = sellXml.attribute( "value" ).as_float();
info.minlevel = levelXml.attribute( "value" ).as_int();
{
std::list<std::string> costs;
split( costs, costXml.attribute( "value" ).as_string() );
for( auto cost : costs )
info.cost.push_back( strToInt( cost ) );
}
{
std::list<std::string> costslab;
split( costslab, costlabXml.attribute( "value" ).as_string() );
for( auto cost : costslab )
info.costlab.push_back( strToInt( cost ) );
}
info.desc = WORD( node.child( "desc" ).attribute( "value" ).as_string() );
info.lab.dmg = node.child( "laboratories_params" ).attribute( "dmg" ).as_int();
info.lab.rng = node.child( "laboratories_params" ).attribute( "rng" ).as_int();
info.lab.spd = node.child( "laboratories_params" ).attribute( "spd" ).as_int();
{//load tower info
unsigned maxlevel( 1 );
for( unsigned i = 1; i <= maxlevel; ++i )
{
pugi::xml_document doc;
pugi::xml_document docTemplate;
doc.load_file( ("ini/units/" + name + intToStr( i ) + ".xml").c_str() );
pugi::xml_node root = doc.root().first_child();
if( maxlevel == 1 )maxlevel = root.attribute( "maxlevel" ).as_int();
if( root.attribute( "template" ) )
docTemplate.load_file( root.attribute( "template" ).as_string() );
auto xmlEffects = root.child( "effects" );
auto xmlMachine = root.child( k::xmlTag::MachineUnit );
if( !xmlEffects )
xmlEffects = docTemplate.root().first_child().child( "effects" );
if( !xmlMachine )
xmlMachine = docTemplate.root().first_child().child( k::xmlTag::MachineUnit );
auto xmlEffectsPositive = xmlEffects.child( "positive" );
auto xmlMachineParams = xmlMachine.child( "params" );
float delayfire = xmlMachineParams.child( "state_readyfire" ).attribute( "delay" ).as_float();
float delaycharge = xmlMachineParams.child( "state_charging" ).attribute( "duration" ).as_float();
unsigned volume = xmlMachineParams.child( "state_readyfire" ).attribute( "charge_volume" ).as_int();
float radius = root.attribute( "radius" ).as_float();
float damage = xmlEffectsPositive.attribute( "damage" ).as_float();
float damageR = xmlEffectsPositive.attribute( "fireRate" ).as_float() *
xmlEffectsPositive.attribute( "fireTime" ).as_float();
float damageI = xmlEffectsPositive.attribute( "iceRate" ).as_float()*
xmlEffectsPositive.attribute( "iceTime" ).as_float();
float damageE = xmlEffectsPositive.attribute( "electroRate" ).as_float()*
xmlEffectsPositive.attribute( "electroTime" ).as_float();
damage += damageR;
damage += damageI;
damage += damageE;
float speed = 1 / (delayfire*volume + delaycharge);
float fps = volume * speed;
damage *= fps;
//log( "%s:%d fps = %f", name.c_str(), i, fps );
//log( "%s:%d damage = %f", name.c_str(), i, damage );
//log( "%s:%d radius = %f", name.c_str(), i, radius );
//log( "%s:%d speed = %f", name.c_str(), i, speed );
assert( damage > 0 );
assert( radius > 0 );
assert( speed > 0 );
info.dmg.push_back( damage );
info.rng.push_back( radius );
info.spd.push_back( speed );
_max_dmg = std::max<float>( _max_dmg, damage );
_max_rng = std::max<float>( _max_rng, radius );
_max_spd = std::max<float>( _max_spd, speed );
}
}
m_towersInfo[name] = info;
}
for( auto & param : m_towersInfo )
{
for( auto& v : param.second.dmg ) v = v / _max_dmg * (parameterMax - parameterMin) + parameterMin;
for( auto& v : param.second.rng ) v = v / _max_rng * (parameterMax - parameterMin) + parameterMin;
for( auto& v : param.second.spd ) v = v / _max_spd * (parameterMax - parameterMin) + parameterMin;
}
}
void ThemeComponent::readXML(std::string path)
{
if(mPath == path)
return;
setDefaults();
deleteComponents();
mPath = path;
if(path.empty())
return;
LOG(LogInfo) << "Loading theme \"" << path << "\"...";
pugi::xml_document doc;
pugi::xml_parse_result result = doc.load_file(path.c_str());
if(!result)
{
LOG(LogError) << "Error parsing theme \"" << path << "\"!\n" << " " << result.description();
return;
}
pugi::xml_node root;
if(!mDetailed)
{
//if we're using the basic view, check if there's a basic version of the theme
root = doc.child("basicTheme");
}
if(!root)
{
root = doc.child("theme");
}
if(!root)
{
LOG(LogError) << "No theme tag found in theme \"" << path << "\"!";
return;
}
//load non-component theme stuff
mColorMap["primary"] = resolveColor(root.child("listPrimaryColor").text().get(), mColorMap["primary"]);
mColorMap["secondary"] = resolveColor(root.child("listSecondaryColor").text().get(), mColorMap["secondary"]);
mColorMap["selector"] = resolveColor(root.child("listSelectorColor").text().get(), mColorMap["selector"]);
mColorMap["selected"] = resolveColor(root.child("listSelectedColor").text().get(), mColorMap["selected"]);
mColorMap["description"] = resolveColor(root.child("descColor").text().get(), mColorMap["description"]);
mColorMap["fastSelect"] = resolveColor(root.child("fastSelectColor").text().get(), mColorMap["fastSelect"]);
mBoolMap["hideHeader"] = root.child("hideHeader") != 0;
mBoolMap["hideDividers"] = root.child("hideDividers") != 0;
//GuiBox theming data
mBoxData.backgroundPath = expandPath(root.child("boxBackground").text().get());
mBoxData.backgroundTiled = root.child("boxBackgroundTiled") != 0;
mBoxData.horizontalPath = expandPath(root.child("boxHorizontal").text().get());
mBoxData.horizontalTiled = root.child("boxHorizontalTiled") != 0;
mBoxData.verticalPath = expandPath(root.child("boxVertical").text().get());
mBoxData.verticalTiled = root.child("boxVerticalTiled") != 0;
mBoxData.cornerPath = expandPath(root.child("boxCorner").text().get());
//list stuff
mBoolMap["listCentered"] = !root.child("listLeftAlign");
mFloatMap["listOffsetX"] = strToFloat(root.child("listOffsetX").text().get(), mFloatMap["listOffsetX"]);
mFloatMap["listTextOffsetX"] = strToFloat(root.child("listTextOffsetX").text().get(), mFloatMap["listTextOffsetX"]);
//game image stuff
std::string artPos = root.child("gameImagePos").text().get();
std::string artDim = root.child("gameImageDim").text().get();
std::string artOrigin = root.child("gameImageOrigin").text().get();
std::string artPosX, artPosY, artWidth, artHeight, artOriginX, artOriginY;
splitString(artPos, ' ', &artPosX, &artPosY);
splitString(artDim, ' ', &artWidth, &artHeight);
splitString(artOrigin, ' ', &artOriginX, &artOriginY);
mFloatMap["gameImageOffsetX"] = resolveExp(artPosX, mFloatMap["gameImageOffsetX"]);
mFloatMap["gameImageOffsetY"] = resolveExp(artPosY, mFloatMap["gameImageOffsetY"]);
mFloatMap["gameImageWidth"] = resolveExp(artWidth, mFloatMap["gameImageWidth"]);
mFloatMap["gameImageHeight"] = resolveExp(artHeight, mFloatMap["gameImageHeight"]);
mFloatMap["gameImageOriginX"] = resolveExp(artOriginX, mFloatMap["gameImageOriginX"]);
mFloatMap["gameImageOriginY"] = resolveExp(artOriginY, mFloatMap["gameImageOriginY"]);
mStringMap["imageNotFoundPath"] = expandPath(root.child("gameImageNotFound").text().get());
//sounds
mSoundMap["menuScroll"]->loadFile(expandPath(root.child("menuScrollSound").text().get()));
mSoundMap["menuSelect"]->loadFile(expandPath(root.child("menuSelectSound").text().get()));
mSoundMap["menuBack"]->loadFile(expandPath(root.child("menuBackSound").text().get()));
mSoundMap["menuOpen"]->loadFile(expandPath(root.child("menuOpenSound").text().get()));
//fonts
mListFont = resolveFont(root.child("listFont"), Font::getDefaultPath(), Renderer::getDefaultFont(Renderer::MEDIUM)->getSize());
mDescFont = resolveFont(root.child("descriptionFont"), Font::getDefaultPath(), Renderer::getDefaultFont(Renderer::SMALL)->getSize());
mFastSelectFont = resolveFont(root.child("fastSelectFont"), Font::getDefaultPath(), Renderer::getDefaultFont(Renderer::LARGE)->getSize());
//actually read the components
createComponentChildren(root, this);
LOG(LogInfo) << "Theme loading complete.";
}
int cr8FColFromStr(cli *c, char *start, uint32 len, float *col) {
return strToFloat(c, start, len, col);
}
char * ICACHE_FLASH_ATTR parse_params_pins_set(const char *params, unsigned int paramslen, gpio_command_params *out, unsigned int all, unsigned int timeout, ALLOWED_FIELDS fields, ALLOWED_FIELDS *readedfields) {
struct jsonparse_state jparser;
if(paramslen)
jsonparse_setup(&jparser, params, paramslen);
else if(fields)
return "No parameters specified";
int type;
int pinnum;
unsigned int pins_found = 0;
unsigned int pinmask;
*readedfields = 0;
load_defaults(out, timeout);
while (jparser.pos < jparser.len) {
type = jsonparse_next(&jparser);
if (type == JSON_TYPE_PAIR_NAME) {
if(strcmp_value(&jparser, "mode") == 0) {
if((fields & AF_UARTMODE) == 0 && (fields & AF_SPIMODE) == 0)
return UNEXPECTED;
jsonparse_next(&jparser);
if(jsonparse_next(&jparser) != JSON_TYPE_ERROR) {
int val;
if(strcmp_value(&jparser, "disable") == 0 && (fields & AF_UARTMODE)) {
*readedfields |= AF_UARTMODE;
out->uart_speed = 0;
continue;
}
int res = strToUInt(&jparser.json[jparser.vstart], &val);
if(!res)
return "Wrong mode integer value";
if(fields & AF_UARTMODE) {
*readedfields |= AF_UARTMODE;
out->uart_speed = val;
if(res < jparser.vlen && jparser.json[jparser.vstart + res] == ' ') {
while(res < jparser.vlen && jparser.json[jparser.vstart + res] == ' ')
res++;
if(res + 3 == jparser.vlen) {
const unsigned char b = jparser.json[jparser.vstart + res] - '0';
const unsigned char p = jparser.json[jparser.vstart + res + 1];
const unsigned char s = jparser.json[jparser.vstart + res + 2] - '0';
if(b < 10 && s < 10) {
out->uart_bits = b;
out->uart_partity = p;
out->uart_stopbits = s;
} else {
return "Wrong mode framing";
}
}
}
}
if(fields & AF_SPIMODE) {
*readedfields |= AF_SPIMODE;
out->spi_mode = val;
}
}
continue;
} else if(strcmp_value(&jparser, "count") == 0) {
char * res = readUIntField(&jparser, AF_COUNT, &out->count, fields, readedfields, 0);
if(res)
return res;
continue;
} else if(strcmp_value(&jparser, "timeout") == 0) {
char * res = readUIntField(&jparser, AF_TIMEOUT, &out->timeout, fields, readedfields, 0);
if(res)
return res;
continue;
} else if(strcmp_value(&jparser, "frequency") == 0) {
if((fields & AF_PERIOD) == 0)
return UNEXPECTED;
float frequncy;
jsonparse_next(&jparser);
if(jsonparse_next(&jparser) != JSON_TYPE_ERROR) {
const int res = strToFloat(&jparser.json[jparser.vstart], &frequncy);
if(!res)
return "Wrong frequency float value";
if(frequncy < 0.000499999f)
out->periodus = 2000004000;
else
out->periodus = 1000000.0f / frequncy;
*readedfields |= AF_PERIOD;
}
continue;
} else if(strcmp_value(&jparser, "address") == 0) {
if((fields & AF_ADDRESS) == 0)
return UNEXPECTED;
jsonparse_next(&jparser);
if(jsonparse_next(&jparser) != JSON_TYPE_ERROR) {
char c;
int p;
if(jparser.json[jparser.vstart] == '0' && jparser.json[jparser.vstart + 1] == 'x')
p = 2;
else
p = 0;
const int res = hexToByte(&jparser.json[jparser.vstart + p], &c);
if(res != (jparser.vlen - p))
return "Address is wrong";
out->address = c;
*readedfields |= AF_ADDRESS;
}
continue;
} else if(strcmp_value(&jparser, "SDA") == 0) {
char * res = readUIntField(&jparser, AF_SDA, &out->SDA, fields, readedfields, 0);
if(res)
return res;
continue;
} else if(strcmp_value(&jparser, "SCL") == 0) {
char * res = readUIntField(&jparser, AF_SCL, &out->SCL, fields, readedfields, 0);
if(res)
return res;
continue;
} else if(strcmp_value(&jparser, "CS") == 0) {
char * res = readUIntField(&jparser, AF_CS, &out->CS, fields, readedfields, ~(uint32_t)0U);
if(res)
return res;
continue;
} else if(strcmp_value(&jparser, "pin") == 0) {
char * res = readUIntField(&jparser, AF_PIN, &out->pin, fields, readedfields, 0);
if(res)
return res;
continue;
} else if(strcmp_value(&jparser, "data") == 0) {
if((fields & AF_DATA) == 0 || out->data_len)
return UNEXPECTED;
jsonparse_next(&jparser);
if(jsonparse_next(&jparser) != JSON_TYPE_ERROR) {
out->data_len = dhdata_decode(&jparser.json[jparser.vstart], jparser.vlen, out->data, sizeof(out->data));
if(out->data_len == 0)
return "Data is broken";
*readedfields |= AF_DATA;
}
continue;
} else if(strcmp_value(&jparser, "text") == 0) {
if((fields & AF_TEXT_DATA) == 0 || out->data_len)
return UNEXPECTED;
jsonparse_next(&jparser);
if(jsonparse_next(&jparser) != JSON_TYPE_ERROR) {
if (jparser.vlen > sizeof(out->data) - 1)
return "Text is too long";
os_memcpy(out->data, &jparser.json[jparser.vstart], jparser.vlen);
out->data[jparser.vlen] = 0;
out->data_len = jparser.vlen;
*readedfields |= AF_TEXT_DATA;
}
continue;
} else if(strcmp_value(&jparser, "all") == 0) {
if(pins_found)
return "Wrong argument";
pins_found = ~(unsigned int)0;
pinmask = all;
pinnum = -1;
} else {
const int res = strToUInt(&jparser.json[jparser.vstart], &pinnum);
if(!res || pinnum < 0 || pinnum > DHGPIO_MAXGPIONUM || (pins_found & (1 << pinnum)))
return "Wrong argument";
pins_found |= (1 << pinnum);
pinmask = (1 << pinnum);
}
jsonparse_next(&jparser);
if(jsonparse_next(&jparser) != JSON_TYPE_ERROR) {
if(strcmp_value(&jparser, "x") == 0)
continue;
else if(strcmp_value(&jparser, "init") == 0) {
if((fields & AF_INIT) == 0)
return UNEXPECTED;
out->pins_to_init |= pinmask;
*readedfields |= AF_INIT;
} else if(strcmp_value(&jparser, "pullup") == 0) {
if((fields & AF_PULLUP) == 0)
return UNEXPECTED;
out->pins_to_pullup |= pinmask;
*readedfields |= AF_PULLUP;
} else if(strcmp_value(&jparser, "nopull") == 0) {
if((fields & AF_NOPULLUP) == 0)
return UNEXPECTED;
out->pins_to_nopull |= pinmask;
*readedfields |= AF_NOPULLUP;
} else if(strcmp_value(&jparser, "disable") == 0) {
if((fields & AF_VALUES) == 0 && (fields & AF_DISABLE) == 0) {
return UNEXPECTED;
}
if (fields & AF_VALUES) {
int i;
if(pinnum > 0 )
out->pin_value[pinnum] = 0;
else for(i = 0; i <= DHGPIO_MAXGPIONUM; i++)
out->pin_value[i] = 0;
out->pin_value_readed |= pinmask;
*readedfields |= AF_VALUES;
}
if(fields & AF_DISABLE) {
out->pins_to_disable |= pinmask;
*readedfields |= AF_DISABLE;
}
} else if(strcmp_value(&jparser, "rising") == 0) {
if((fields & AF_RISING)== 0)
return UNEXPECTED;
out->pins_to_rising |= pinmask;
*readedfields |= AF_RISING;
} else if(strcmp_value(&jparser, "falling") == 0) {
if((fields & AF_FALLING) == 0)
return UNEXPECTED;
out->pins_to_falling |= pinmask;
*readedfields |= AF_FALLING;
} else if(strcmp_value(&jparser, "both") == 0) {
if((fields & AF_BOTH) == 0)
return UNEXPECTED;
out->pins_to_both |= pinmask;
*readedfields |= AF_BOTH;
} else if(strcmp_value(&jparser, "read") == 0) {
if((fields & AF_READ) == 0)
return UNEXPECTED;
out->pins_to_read |= pinmask;
*readedfields |= AF_READ;
} else if(strcmp_value(&jparser, "presence") == 0) {
if((fields & AF_PRESENCE) == 0)
return UNEXPECTED;
out->pins_to_presence |= pinmask;
*readedfields |= AF_PRESENCE;
} else if((fields & AF_VALUES)) { // BE CAREFULL, all digits values have to be under this if
int value, i;
if(!strToUInt(&jparser.json[jparser.vstart], &value))
return NONINTEGER;
if(pinnum > 0 )
out->pin_value[pinnum] = value;
else for(i = 0; i <= DHGPIO_MAXGPIONUM; i++)
out->pin_value[i] = value;
out->pin_value_readed |= pinmask;
*readedfields |= AF_VALUES;
if(value == 1 && (fields & AF_SET)) {
out->pins_to_set |= pinmask;
*readedfields |= AF_SET;
} else if(value == 0 && (fields & AF_CLEAR)) {
out->pins_to_clear |= pinmask;
*readedfields |= AF_CLEAR;
}
} else if(strcmp_value(&jparser, "1") == 0) {
if((fields & AF_SET) == 0)
return UNEXPECTED;
out->pins_to_set |= pinmask;
*readedfields |= AF_SET;
} else if(strcmp_value(&jparser, "0") == 0) {
if((fields & AF_CLEAR) == 0)
return UNEXPECTED;
out->pins_to_clear |= pinmask;
*readedfields |= AF_CLEAR;
} else {
return "Unsupported action";
}
}
} else if(type == JSON_TYPE_ERROR) {
return "Broken json";
}
}
return NULL;
}
int main(void)
{
strToFloat("-867.6921");
return 0;
}
void EnemyFactory::createEnemy( TiXmlNode *enemyNode)
{
TiXmlNode *node;
TiXmlElement *elem;
LPathManager &lpm = *LPathManagerS::instance();
LEnemy *enemy = new LEnemy();
elem = enemyNode->ToElement();
enemy->spawnTime = strToFloat( elem->Attribute("spawnTime"));
EnemyType enemyType = eSimpleEnemy;
if( elem->Attribute("type"))
enemyType = (EnemyType)strToInt(elem->Attribute("type"));
node = enemyNode->FirstChild("Model");
elem = node->ToElement();
enemy->modelName = elem->Attribute("Name");
node = enemyNode->FirstChild("SpawnPoint");
elem = node->ToElement();
enemy->spawnPoint.x = strToFloat( elem->Attribute("x"));
enemy->spawnPoint.y = strToFloat( elem->Attribute("y"));
enemy->spawnPoint.z = strToFloat( elem->Attribute("z"));
node = enemyNode->FirstChild("Home");
elem = node->ToElement();
enemy->home.x = strToFloat( elem->Attribute("x"));
enemy->home.y = strToFloat( elem->Attribute("y"));
enemy->home.z = strToFloat( elem->Attribute("z"));
node = enemyNode->FirstChild("EntryPath");
elem = node->ToElement();
enemy->entry = lpm.getPath( elem->Attribute("Name"));
node = enemyNode->FirstChild("IdlePath");
elem = node->ToElement();
enemy->idle = lpm.getPath( elem->Attribute("Name"));
node = enemyNode->FirstChild("AttackPath");
enemy->numAttackPaths = countSiblings( node, "AttackPath");
enemy->attack = new LPath*[ enemy->numAttackPaths];
for( int i=0; i< enemy->numAttackPaths; i++)
{
elem = node->ToElement();
enemy->attack[ i] = lpm.getPath( elem->Attribute("Name"));
node = node->NextSibling( "AttackPath");
}
node = enemyNode->FirstChild("RetreatPath");
enemy->numRetreatPaths = countSiblings( node, "RetreatPath");
enemy->retreat = new LPath*[ enemy->numRetreatPaths];
for( int i=0; i< enemy->numRetreatPaths; i++)
{
elem = node->ToElement();
enemy->retreat[ i] = lpm.getPath( elem->Attribute("Name"));
node = node->NextSibling( "RetreatPath");
}
switch( enemyType)
{
default:
case eSimpleEnemy:
new SimpleEnemy( enemy);
break;
case eBoss1:
new Boss1Enemy( enemy);
break;
}
}
//-----------------------------------------------------------------------------
// 描述: 以浮点型返回字段值 (若转换失败则返回缺省值)
//-----------------------------------------------------------------------------
double DbField::asFloat(double defaultVal) const
{
return strToFloat(asString(), defaultVal);
}
int main(void) {
printf("%lf\n", strToFloat("867.6921"));
printf("%lf\n", strToFloat("-867.6921"));
return 0;
}
