/**
* Generate LaTeX code for "prefix", a 1sample-delay explicitely initialized.
*
* @param sig The signal expression to treat.
* @param x The initial value for the delay line.
* @param e The value for the delay line, after initialization.
* @param priority The priority of the environment of the expression.
*
* @return <string> The LaTeX code translation of the signal, cached.
*/
string DocCompiler::generatePrefix(Tree sig, Tree x, Tree e, int priority)
{
string var = getFreshID("m");
string exp0 = CS(x, priority);
string exp1 = CS(e, priority); // ensure exp1 is compiled to have a vector name
string vecname;
if(!getVectorNameProperty(e, vecname))
{
cerr << "No vector name for : " << ppsig(e) << endl;
assert(0);
}
string ltqPrefixDef;
ltqPrefixDef += subst("$0(t) = \n", var);
ltqPrefixDef += "\\left\\{\\begin{array}{ll}\n";
ltqPrefixDef += subst("$0 & \\mbox{, when \\,} t = 0\\\\\n", exp0);
ltqPrefixDef += subst("$0 & \\mbox{, when \\,} t > 0\n", subst("$0(t\\!-\\!1)", vecname));
ltqPrefixDef += "\\end{array}\\right.";
fLateq->addPrefixSigFormula(ltqPrefixDef);
gDocNoticeFlagMap["prefixsigs"] = true;
return generateCacheCode(sig, subst("$0(t)", var));
}
string DocCompiler::generateNumEntry(Tree sig, Tree path, Tree cur, Tree min, Tree max, Tree step)
{
string varname = getFreshID("{u_n}") + "(t)";
fLateq->addUISigFormula(getUIDir(path), prepareIntervallicUI(varname, path, cur, min, max));
gDocNoticeFlagMap["nentrysigs"] = true;
return generateCacheCode(sig, varname);
}
Lateq* DocCompiler::compileLateq (Tree L, Lateq* compiledEqn)
{
//cerr << "Documentator : compileLateq : L = "; printSignal(L, stdout, 0); cerr << endl;
fLateq = compiledEqn; ///< Dynamic field !
int priority = 0;
for (int i = 0; isList(L); L = tl(L), i++) {
Tree sig = hd(L);
Tree id;
if(getSigNickname(sig, id)) {
//cerr << "Documentator : compileLateq : NICKNAMEPROPERTY = " << tree2str(id) << endl;
fLateq->addOutputSigFormula(subst("$0(t) = $1", tree2str(id), CS(sig, priority), docT(i)));
} else {
//cerr << "Documentator : compileLateq : NO NICKNAMEPROPERTY" << endl;
if (fLateq->outputs() == 1) {
fLateq->addOutputSigFormula(subst("y(t) = $0", CS(sig, priority)));
gGlobal->gDocNoticeFlagMap["outputsig"] = true;
} else {
fLateq->addOutputSigFormula(subst("$0(t) = $1", getFreshID("y"), CS(sig, priority)));
gGlobal->gDocNoticeFlagMap["outputsigs"] = true;
}
}
}
return fLateq;
}
string DocCompiler::generateCheckbox(Tree sig, Tree path)
{
string vname = getFreshID("{u_c}");
string varname = vname + "(t)";
fLateq->addUISigFormula(getUIDir(path), prepareBinaryUI(varname, path));
gDocNoticeFlagMap["checkboxsigs"] = true;
return generateCacheCode(sig, varname);
}
string DocCompiler::generateHBargraph(Tree sig, Tree path, Tree min, Tree max, const string& exp)
{
string varname = getFreshID("{u_g}");
Type t = getCertifiedSigType(sig);
switch (t->variability()) {
case kKonst :
break;
case kBlock :
break;
case kSamp :
break;
}
return generateCacheCode(sig, varname);
}
/**
* Generate a select2 code
*/
string DocCompiler::generateSelect2(Tree sig, Tree sel, Tree s1, Tree s2, int priority)
{
string var = getFreshID("q");
string expsel = CS(sel, 0);
string exps1 = CS(s1, 0);
string exps2 = CS(s2, 0);
string ltqSelDef;
ltqSelDef += subst("$0(t) = \n", var);
ltqSelDef += "\\left\\{\\begin{array}{ll}\n";
ltqSelDef += subst("$0 & \\mbox{if \\,} $1 = 0\\\\\n", exps1, expsel);
ltqSelDef += subst("$0 & \\mbox{if \\,} $1 = 1\n", exps2, expsel);
ltqSelDef += "\\end{array}\\right.";
fLateq->addSelectSigFormula(ltqSelDef);
gDocNoticeFlagMap["selectionsigs"] = true;
// return generateCacheCode(sig, subst("$0(t)", var));
setVectorNameProperty(sig, var);
return subst("$0(t)", var);
}
// The parser takes the ASCII level and modify the the TileMap and the EntityVector
void Mapper::parse(std::string asciiLevel, TileMap& tiles, EntityMap& entities, Elodie& elodie)
{
unsigned int y = 0;
unsigned int x = 0;
bool isEntity = true;
for(size_t i = 0; i < asciiLevel.length(); i++)
{
isEntity = true;
if(y >= tiles.size())
{
tiles.push_back(std::vector<TileSprite*>());
}
// Entities
switch(asciiLevel[i])
{
case MAP_ELODIE:
elodie.reset();
elodie.setPosition(x*32 - 21, y*32 - 32);
entities.insert(std::make_pair("elodie", &elodie));
break;
case MAP_SHEEP:
entities.insert(std::make_pair(getFreshID("sheep"), new Sheep(x*32, y*32)));
break;
case MAP_MAGMACUBE:
entities.insert(std::make_pair(getFreshID("magmacube"), new MagmaCube(x*32, y*32)));
break;
case MAP_GHOST:
entities.insert(std::make_pair(getFreshID("ghost"), new Ghost(x*32, y*32)));
break;
case MAP_BRISTLE:
entities.insert(std::make_pair(getFreshID("bristle"), new Bristle(x*32, y*32)));
break;
case MAP_SPIKES:
entities.insert(std::make_pair(getFreshID("spikes"), new Spikes(x*32, y*32)));
break;
case MAP_LASER:
entities.insert(std::make_pair(getFreshID("laser"), new Laser(x*32, y*32)));
break;
case MAP_ALIEN:
entities.insert(std::make_pair(getFreshID("alien"), new Alien(x*32, y*32)));
break;
case MAP_METEORITE:
entities.insert(std::make_pair(getFreshID("meteorite"), new Meteorite(x*32, y*32)));
break;
case MAP_RAVEN:
entities.insert(std::make_pair(getFreshID("raven"), new Raven(x*32, y*32)));
break;
case MAP_PORTAL:
if(entities.find("portal") == entities.end())
{
entities.insert(std::make_pair("portal", new Portal(x*32, y*32, ENTITYTYPE_MISC, ENTITYNAME_PORTAL, EntityType::MISC, EntityName::PORTAL)));
}
break;
case MAP_ROCKET:
if(entities.find("portal") == entities.end())
{
entities.insert(std::make_pair("portal", new Portal(x*32, y*32, ENTITYTYPE_MISC, ENTITYNAME_ROCKET, EntityType::MISC, EntityName::ROCKET)));
}
break;
case MAP_PORO:
entities.insert(std::make_pair(getFreshID("poro"), new Poro(x*32, y*32)));
break;
case MAP_BONUS:
entities.insert(std::make_pair(getFreshID("bonus"), new Bonus(x*32, y*32)));
break;
default:
isEntity = false;
break;
}
switch(asciiLevel[i])
{
// Terrain
case MAP_GROUND:
tiles[y].push_back(new TileSprite(TileType::ROCK));
break;
case MAP_ICE:
tiles[y].push_back(new TileSprite(TileType::ICE));
break;
case MAP_DIRT:
tiles[y].push_back(new TileSprite(TileType::DIRT));
break;
case MAP_BOX:
tiles[y].push_back(new TileSprite(TileType::BOX));
break;
case MAP_METAL:
tiles[y].push_back(new TileSprite(TileType::METAL));
break;
case MAP_ASTEROID:
tiles[y].push_back(new TileSprite(TileType::ASTEROID));
break;
case MAP_LINE_BREAK:
y++;
x=-1;
break;
case MAP_NULL:
case MAP_NULL2:
tiles[y].push_back(NULL);
break;
default:
tiles[y].push_back(NULL);
if(!isEntity)
{
std::cerr << "[Warning] Mapper: tile type not found: '" << asciiLevel[i] << "'" << std::endl;
}
break;
}
++x;
}
}
