//add a task to runTimeStorage
//no duplicate task is allowed.
void RunTimeStorage::add(Task task) {
if (isDuplicate(task)) {
throw DUPLICATE_TASK_EXCEPTION();
}
_tasks.push_back(task);
return;
}
int main(){
int i, numUnique = 0, b, a;
short uniqueNum[10000][30] = {{0}};
short basePrimeFactor[30] = {0}, curr[30] = {0};
genPrimes();
for (a = 2; a <= 100; a++){
memset(basePrimeFactor, 0, sizeof(short)*30);
factorize(a, basePrimeFactor);
for (b = 2; b <= 100; b++){
for (i = 0; i < 30; i++){
curr[i] = basePrimeFactor[i]*b;
}
if (!isDuplicate(curr, uniqueNum, numUnique)){
memcpy(uniqueNum[numUnique], curr, sizeof(short)*30);
numUnique++;
}
}
}
printf("%d\n", numUnique);
return 0;
}
/*
* this should be part of a child class, but I'm lazy right now
*/
void TreeModel::xBasicIncludes(QString &text)
{
QString inc, cap, s;
QStringList st = text.split('\n');
QRegExp rx("(include) ([^\n]*)");
rx.setCaseSensitivity(Qt::CaseInsensitive);
int len = st.length();
for(int n = 0; n < len; n++)
{
s = st.at(n);
int gotit = rx.indexIn(s);
if(gotit > -1) {
QList<QVariant> clist;
inc = rx.cap(1);
cap = rx.cap(2);
if(cap != "" && cap.indexOf("\"") > -1) {
QStringList caps = cap.split("\"");
cap = caps.at(1);
cap = cap.trimmed();
clist << cap;
if(!isDuplicate(rootItem, cap))
rootItem->appendChild(new TreeItem(clist, rootItem));
}
}
}
}
UtlBoolean
SipLineList::isDuplicate( SipLine *line )
{
// Changed this to call common code
Url lineIdentityUrl = line->getIdentity();
return isDuplicate( lineIdentityUrl );
}
void Receiver::received(Message& message)
{
if (!(skipDups && isDuplicate(message))) {
bool eos = message.getData() == EOS;
if (!eos) std::cout << message.getData() << std::endl;
if (eos || ++processed == count) subscription.cancel();
}
}
void Widget::processCookies(Cookies cookies) {
if (isDuplicate(cookies))
return;
cookiesMgr_.push_back(cookies);
CookieTreeWidgetItem* item = new CookieTreeWidgetItem(ui->twCookie, cookies);
item->setFlags(item->flags() | Qt::ItemIsEditable);
item->setText(0, cookies.time.toString("hh:mm:ss"));
item->setText(1, cookies.ip);
item->setText(2, cookies.url);
}
void OpenEditorsModel::makeOriginal(IEditor *duplicate)
{
Q_ASSERT(duplicate && isDuplicate(duplicate));
IEditor *original = originalForDuplicate(duplicate);
Q_ASSERT(original);
int i = findEditor(original);
m_editors[i].editor = duplicate;
m_duplicateEditors.removeOne(duplicate);
m_duplicateEditors.append(original);
disconnect(original, SIGNAL(changed()), this, SLOT(itemChanged()));
connect(duplicate, SIGNAL(changed()), this, SLOT(itemChanged()));
}
/*
* this should be part of a child class, but I'm lazy right now
*/
void TreeModel::xBasicIncludes(QString &filePath, QString &incPath, QString &separator, QString &text, bool root)
{
QString inc, cap, s;
QStringList st = text.split('\n');
QRegExp rx("(include) ([^\n]*)");
rx.setCaseSensitivity(Qt::CaseInsensitive);
int len = st.length();
for(int n = 0; n < len; n++)
{
s = st.at(n);
int gotit = rx.indexIn(s);
if(gotit > -1) {
QList<QVariant> clist;
inc = rx.cap(1);
cap = rx.cap(2);
if(cap != "" && cap.indexOf("\"") > -1) {
QStringList caps = cap.split("\"");
cap = caps.at(1);
cap = cap.trimmed();
clist << cap;
if(!isDuplicate(rootItem, cap))
rootItem->appendChild(new TreeItem(clist, rootItem));
}
QString newPath = filePath.mid(0,(filePath.lastIndexOf(separator)+1))+cap;
QString newInc = incPath+cap;
if(QFile::exists(newPath) == true)
{
QString filename = newPath;
QFile myfile(filename);
if (myfile.open(QFile::ReadOnly | QFile::Text))
{
text = myfile.readAll();
myfile.close();
xBasicIncludes(filename, incPath, separator, text);
}
}
else if(QFile::exists(newInc) == true)
{
QString filename = newInc;
QFile myfile(filename);
if (myfile.open(QFile::ReadOnly | QFile::Text))
{
text = myfile.readAll();
myfile.close();
xBasicIncludes(filename, incPath, separator, text);
}
}
}
}
}
void generateDatabase(registration (&database)[NUM_REGISTRATIONS])
{
int regCount = 0;
while (regCount < NUM_REGISTRATIONS)
{
registration reg = generateRegistration();
if (!isDuplicate(regCount, reg, database))
{
database[regCount] = reg;
regCount++;
}
}
}
// send smth to address 'addr', port 'port'
void networkingForwardData(MacInfo_t *macInfo, uint8_t *data, uint16_t len) {
// PRINTF("commForwardData, len=%u\n", len);
switch (routePacket(macInfo)) {
case RD_DROP:
// PRINTF("RD_DROP\n");
if (IS_LOCAL(macInfo)){
INC_NETSTAT(NETSTAT_PACKETS_DROPPED_TX, EMPTY_ADDR);
} else{
INC_NETSTAT(NETSTAT_PACKETS_DROPPED_RX, EMPTY_ADDR);
}
break;
case RD_LOCAL:
// PRINTF("RD_LOCAL\n");
socketInputData(macInfo, data, len);
break;
case RD_UNICAST:
// PRINTF("RD_UNICAST\n");
// force header rebuild
macInfo->macHeaderLen = 0;
#if PLATFORM_SADMOTE
if (!IS_LOCAL(macInfo) && isDuplicate(macInfo, data, len)) {
PRINTF("not forwarding, duplicate...\n");
break;
}
#endif
if (IS_LOCAL(macInfo)) {
INC_NETSTAT(NETSTAT_PACKETS_SENT, macInfo->originalDst.shortAddr);
}
macSendEx(macInfo, data, len);
break;
case RD_BROADCAST:
// PRINTF("RD_BROADCAST\n");
if (!IS_LOCAL(macInfo)) {
socketInputData(macInfo, data, len);
}
// and forward to all
intToAddr(macInfo->originalDst, OSW_ADDR_BROADCAST);
// force header rebuild
macInfo->macHeaderLen = 0;
INC_NETSTAT(NETSTAT_PACKETS_SENT, EMPTY_ADDR);
macSendEx(macInfo, data, len);
break;
}
}
void ConvexBuilder::getMesh(const ConvexResult &cr,VertexLookup vc,UintVector &indices)
{
unsigned int *src = cr.mHullIndices;
for (unsigned int i=0; i<cr.mHullTcount; i++)
{
unsigned int i1 = *src++;
unsigned int i2 = *src++;
unsigned int i3 = *src++;
const float *p1 = &cr.mHullVertices[i1*3];
const float *p2 = &cr.mHullVertices[i2*3];
const float *p3 = &cr.mHullVertices[i3*3];
i1 = Vl_getIndex(vc,p1);
i2 = Vl_getIndex(vc,p2);
i3 = Vl_getIndex(vc,p3);
#if 0
bool duplicate = false;
unsigned int tcount = indices.size()/3;
for (unsigned int j=0; j<tcount; j++)
{
unsigned int ci1 = indices[j*3+0];
unsigned int ci2 = indices[j*3+1];
unsigned int ci3 = indices[j*3+2];
if ( isDuplicate(i1,i2,i3, ci1, ci2, ci3 ) )
{
duplicate = true;
break;
}
}
if ( !duplicate )
{
indices.push_back(i1);
indices.push_back(i2);
indices.push_back(i3);
}
#endif
}
}
void getDir(std::string dir, filepath * map, std::ofstream &outfile){
//directory pointer
DIR *directory;//DIR: a type representing a directory stream, display a list of files and subfolders
//dir entry pointer
struct dirent * enter;
struct stat buf;
std::cout << "dir is: " << dir << std::endl;
directory = opendir(dir.c_str()); //DIR* opendir(const char *)
std::cout << "The directory is " << directory << std::endl;
if (dir.at(dir.length() - 1) != '/'){
dir = dir + "/";
}
if (directory != NULL){
while ((enter = readdir(directory))){
if (strcmp(enter->d_name, ".") != 0 && strcmp(enter->d_name, "..") != 0){
if (lstat((dir + enter->d_name).c_str(), &buf) != -1){
if (S_ISDIR(buf.st_mode)) {
//protection mode; S_ISDIR:test for a directory
std::cout << "a directory!\n";
getDir(dir + enter->d_name, map, outfile);
}
else if (S_ISREG(buf.st_mode)){//S_ISREG: test for a regular file
std::cout << "a file!\n";
std::string fnameMapped = isDuplicate(map, dir+enter->d_name);
if (fnameMapped != "") {
showInScript(outfile, dir+enter->d_name, fnameMapped);
}
else {
addToMap(map, dir+enter->d_name);
}
}
}
else {
perror("Could not get the file information!");
}
}
}
closedir(directory);
}
else {
perror("Could not open the directory!");
}
}
int main(int argc, char *argv[])
{
int x, y, i, OK, startIndex;
char name[20];
SDL_Rect src, dest;
unsigned char r, g, b;
int *pixels, xx, yy, pixel;
int colour;
i = 0;
if (argc != 3)
{
printf("Usage: %s <PNG File> <Start_Index>\n", argv[0]);
exit(0);
}
atexit(cleanup);
if (SDL_Init(SDL_INIT_VIDEO|SDL_INIT_JOYSTICK|SDL_INIT_AUDIO) < 0)
{
printf("Could not initialize SDL: %s\n", SDL_GetError());
exit(1);
}
screen = SDL_SetVideoMode(SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0);
image = loadImage(argv[1]);
i = atoi(argv[2]);
startIndex = i;
temp = SDL_CreateRGBSurface(SDL_HWSURFACE, TILE_SIZE, TILE_SIZE, image->format->BitsPerPixel, image->format->Rmask, image->format->Gmask, image->format->Bmask, 0);
newSurface = SDL_DisplayFormat(temp);
colour = SDL_MapRGB(image->format, TRANS_R, TRANS_G, TRANS_B);
for (y=0;y<image->h;y+=TILE_SIZE)
{
for (x=0;x<image->w;x+=TILE_SIZE)
{
SDL_FillRect(newSurface, NULL, colour);
src.x = x;
src.y = y;
src.w = image->w - x >= TILE_SIZE ? TILE_SIZE : image->w - x;
src.h = image->h - y >= TILE_SIZE ? TILE_SIZE : image->h - y;
dest.x = 0;
dest.y = 0;
dest.w = src.w;
dest.h = src.h;
SDL_BlitSurface(image, &src, newSurface, &dest);
sprintf(name, "%d.png", i);
OK = 0;
for (yy=0;yy<newSurface->h;yy++)
{
for (xx=0;xx<newSurface->w;xx++)
{
pixels = (int *)newSurface->pixels;
pixel = pixels[(yy * newSurface->w) + xx];
SDL_GetRGB(pixel, newSurface->format, &r, &g, &b);
if (r != TRANS_R && g != TRANS_G && b != TRANS_B)
{
OK = 1;
break;
}
}
}
if (OK == 1 && isDuplicate(newSurface, startIndex, i) == FALSE)
{
printf("Saving %s\n", name);
savePNG(newSurface, name);
i++;
}
}
}
exit(0);
}
bool QComposeInputContext::checkComposeTable()
{
QVector<QComposeTableElement>::const_iterator it =
std::lower_bound(m_composeTable.constBegin(), m_composeTable.constEnd(), m_composeBuffer, Compare());
// prevent dereferencing an 'end' iterator, which would result in a crash
if (it == m_composeTable.constEnd())
it -= 1;
QComposeTableElement elem = *it;
// would be nicer if qLowerBound had API that tells if the item was actually found
if (m_composeBuffer[0] != elem.keys[0]) {
#ifdef DEBUG_COMPOSING
qDebug( "### no match ###" );
#endif
reset();
return false;
}
// check if compose buffer is matched
for (int i=0; i < QT_KEYSEQUENCE_MAX_LEN; i++) {
// check if partial match
if (m_composeBuffer[i] == 0 && elem.keys[i]) {
#ifdef DEBUG_COMPOSING
qDebug("### partial match ###");
#endif
return true;
}
if (m_composeBuffer[i] != elem.keys[i]) {
#ifdef DEBUG_COMPOSING
qDebug("### different entry ###");
#endif
reset();
return i != 0;
}
}
#ifdef DEBUG_COMPOSING
qDebug("### match exactly ###");
#endif
// check if the key sequence is overwriten - see the comment in
// TableGenerator::orderComposeTable()
int next = 1;
do {
// if we are at the end of the table, then we have nothing to do here
if (it + next != m_composeTable.end()) {
QComposeTableElement nextElem = *(it + next);
if (isDuplicate(elem, nextElem)) {
elem = nextElem;
next++;
continue;
} else {
break;
}
}
break;
} while (true);
commitText(elem.value);
reset();
return true;
}
WirelessParser::ParsePacketResult WirelessParser::parseAsPacket_ASPP_v2(DataBuffer& data, WirelessPacket& packet, WirelessTypes::Frequency freq)
{
//Assume we are at the start of the packet, read the packet header
//byte 1 - Start Of Packet
//byte 2 - Delivery Stop Flag
//byte 3 - App Data Type
//byte 4 - 7 - Node Address (uint32)
//byte 8 - 9 - Payload Length
//byte 10 to N-4 - Payload
//byte N-3 - Node RSSI
//byte N-2 - Base RSSI
//byte N-1 - Fletcher Checksum (MSB)
//byte N - Fletcher Checksum (LSB)
//create a save point for the DataBuffer
ReadBufferSavePoint savePoint(&data);
std::size_t totalBytesAvailable = data.bytesRemaining();
//we need at least 13 bytes for any ASPP v2 packet (if empty payload)
if(totalBytesAvailable < 13)
{
//Not Enough Data to tell if valid packet
return parsePacketResult_notEnoughData;
}
//read byte 1
uint8 startOfPacket = data.read_uint8(); //Start Of Packet
//verify that the first byte is the Start Of Packet
if(startOfPacket != WirelessPacket::ASPP_V2_START_OF_PACKET_BYTE)
{
//Invalid Packet
return parsePacketResult_invalidPacket;
}
//read byte 2
uint8 deliveryStopFlag = data.read_uint8(); //Delivery Stop Flag
//read byte 3
uint8 appDataType = data.read_uint8(); //App Data Type
//read bytes 4 - 7
uint32 nodeAddress = data.read_uint32(); //Node Address
//read bytes 8 and 9
uint16 payloadLength = data.read_uint16(); //Payload Length
//determine the full packet length
size_t packetLength = payloadLength + WirelessPacket::ASPP_V2_NUM_BYTES_BEFORE_PAYLOAD + WirelessPacket::ASPP_V2_NUM_BYTES_AFTER_PAYLOAD;
//the DataBuffer must be large enough to hold the rest of the packet
if(totalBytesAvailable < packetLength)
{
//Not Enough Data to tell if valid packet
return parsePacketResult_notEnoughData;
}
//create the Bytes vector to hold the payload bytes
Bytes payload;
payload.reserve(payloadLength);
//loop through the payload
for(uint16 payloadItr = 0; payloadItr < payloadLength; payloadItr++)
{
//store the payload bytes
payload.push_back(data.read_uint8()); //Payload Bytes
}
//read the node RSSI
uint8 nodeRSSI = data.read_uint8(); //Node RSSI
//read the base station rssi
uint8 baseRSSI = data.read_uint8(); //Base RSSI
//get the checksum sent in the packet
uint16 checksum = data.read_uint16(); //Checksum
//build the checksum to calculate from all the bytes
ChecksumBuilder calcChecksum;
calcChecksum.append_uint8(startOfPacket);
calcChecksum.append_uint8(deliveryStopFlag);
calcChecksum.append_uint8(appDataType);
calcChecksum.append_uint32(nodeAddress);
calcChecksum.append_uint16(payloadLength);
calcChecksum.appendBytes(payload);
calcChecksum.append_uint8(nodeRSSI);
calcChecksum.append_uint8(baseRSSI);
//verify that the returned checksum is the same as the one we calculated
if(checksum != calcChecksum.fletcherChecksum())
{
//Bad Checksum
return parsePacketResult_badChecksum;
}
DeliveryStopFlags flags = DeliveryStopFlags::fromByte(deliveryStopFlag);
//add all the info about the packet to the WirelessPacket reference passed in
packet.deliveryStopFlags(flags);
packet.type(static_cast<WirelessPacket::PacketType>(appDataType));
packet.nodeAddress(nodeAddress);
packet.payload(payload);
packet.nodeRSSI(static_cast<int16>(nodeRSSI) - 205);
packet.baseRSSI(static_cast<int16>(baseRSSI) - 205);
packet.frequency(freq);
//Correct the packet type if it is incorrect
WirelessPacketUtils::correctPacketType(packet);
//make sure the packet is valid based on its specific type
if(!WirelessPacketUtils::packetIntegrityCheck(packet))
{
//not a valid packet, failed integrity check
return parsePacketResult_invalidPacket;
}
//check if the packet is a duplicate
if(isDuplicate(packet))
{
//even though it is a duplicate, we still have a complete packet so commit the bytes to skip over them
savePoint.commit();
//duplicate packet
return parsePacketResult_duplicate;
}
//we have a complete packet, commit the bytes that we just read (move the read pointer)
savePoint.commit();
return parsePacketResult_completePacket;
}
/** Check if this packet is a duplicate
*
* Registers the sequence number as received if it is the first copy of the packet.
* All subsequent received copies (duplicates) are dropped and the packet count is
* increased, if the first copy is still in the packet trap.
*
* Looping packets sent by this host are also dropped.
* The hop count value in the corresponding extension is incremented.
*/
int checkSeq(dessert_msg_t* msg, size_t len, dessert_msg_proc_t *proc, dessert_meshif_t *iface, dessert_frameid_t id) {
if(/*proc->lflags & DESSERT_RX_FLAG_L2_SRC
||*/ proc->lflags & DESSERT_RX_FLAG_L25_SRC) {
// TODO gossip_10
dessert_debug("dropped looping packet from myself");
return DESSERT_MSG_DROP;
}
seqlog_t* s = NULL;
u_char* shost = dessert_msg_getl25ether(msg)->ether_shost;
/*###*/
pthread_rwlock_rdlock(&seqlog_lock);
HASH_FIND(hh, seqlog, shost, ETHER_ADDR_LEN, s);
pthread_rwlock_unlock(&seqlog_lock);
/*###*/
bool seq2_duplicate = false;
if(s) {
/*###*/
pthread_rwlock_wrlock(&seqlog_lock);
uint8_t dup = isDuplicate(s, msg->u16);
if(!dup) {
insertSeq(s, msg->u16);
#ifndef ANDROID
seq2_duplicate = gossip13_rx_packet(s, msg, false);
#endif
pthread_rwlock_unlock(&seqlog_lock);
/*###*/
}
else {
pthread_rwlock_unlock(&seqlog_lock);
/*###*/
if(!(msg->u8 & HELLO)) { // HELLOs are never trapped
trappedpacket_t* t;
pkey_t lookup_key;
memcpy(lookup_key.addr, shost, ETHER_ADDR_LEN);
lookup_key.seq = msg->u16;
/*###*/
pthread_rwlock_wrlock(&packettrap_lock);
HASH_FIND(hh, trappedpackets, &lookup_key, sizeof(pkey_t), t);
if(t) {
// TODO gossip_10
t->counter++;
}
pthread_rwlock_unlock(&packettrap_lock);
/*###*/
}
return DESSERT_MSG_DROP;
}
}
else {
s = malloc(sizeof(seqlog_t));
if(!s) {
dessert_crit("could not allocate memory");
return DESSERT_MSG_KEEP;
}
uint16_t i = 0;
for(i=0; i<LOG_SIZE; i++) {
s->seqs[i] = msg->u16;
}
s->next_seq = 1;
#ifndef ANDROID
// what the other node tells me
gossip13_new_history(&(s->rx_history), false); // does not require observation initialization
gossip13_new_history(&(s->tx_history), false); // does not require observation initialization
gossip13_new_history(&(s->total_tx_history), false); // does not require observation initialization
gossip13_new_history_mean(&(s->hops_history), false); // does not require observation initialization
gossip13_new_history(&(s->nodes_history), false); // does not require observation initialization
gossip13_new_history_mean(&(s->mean_dist_history), false); // does not require observation initialization
gossip13_new_history_mean(&(s->eccentricity_history), false); // does not require observation initialization
// what I know about the other node
gossip13_new_history(&(s->observed_history), true);
gossip13_new_observation(&(s->observed_history->observations));
gossip13_new_history_mean(&(s->my_hops_history), true);
gossip13_new_observation_mean(&(s->my_hops_history->observations));
#endif
s->tau = 0;
memcpy(s->addr, shost, ETHER_ADDR_LEN);
dessert_debug("registering seq=%d for src=" MAC " (previously unknown host)", msg->u16, EXPLODE_ARRAY6(shost));
#ifndef ANDROID
seq2_duplicate = gossip13_rx_packet(s, msg, true);
#endif
/*###*/
pthread_rwlock_wrlock(&seqlog_lock);
HASH_ADD(hh, seqlog, addr, ETHER_ADDR_LEN, s);
pthread_rwlock_unlock(&seqlog_lock);
/*###*/
}
#ifndef ANDROID
if(seq2_duplicate && gossip13_drop_seq2_duplicates
&& (proc->lflags & DESSERT_RX_FLAG_L25_DST || proc->lflags & DESSERT_RX_FLAG_L25_BROADCAST)) {
return DESSERT_MSG_DROP;
}
#endif
dessert_ext_t* ext = NULL;
if(dessert_msg_getext(msg, &ext, EXT_HOPS, 0)) {
gossip_ext_hops_t* h = (gossip_ext_hops_t*) ext->data;
h->hops++;
}
return DESSERT_MSG_KEEP;
}
//add a task into specified index in _tasks
//used for undo only as _entryOrder need to be maintained
void RunTimeStorage::insert(Task task, size_t index) {
assert(!isDuplicate(task));
_tasks.insert(_tasks.begin()+index, task);
return;
}
void KeyDefMenuUserInterface::render() const
{
// Draw the game screen, then dim it out so you can still see it under our overlay
if(getGame()->getConnectionToServer())
getUIManager()->renderAndDimGameUserInterface();
mGL->glColor(Colors::white);
RenderUtils::drawCenteredString(vertMargin, 30, mMenuTitle);
RenderUtils::drawCenteredString(vertMargin + 35, 18, mMenuSubTitle);
mGL->glColor(Colors::menuHelpColor);
RenderUtils::drawCenteredString(vertMargin + 63, 14, "You can define different keys for keyboard or joystick mode. Switch in Options menu.");
mGL->glColor(Colors::white);
RenderUtils::drawCenteredString(DisplayManager::getScreenInfo()->getGameCanvasHeight() - vertMargin - 20, 18, mMenuFooter);
TNLAssert(selectedIndex < menuItems.size(), "Index out of bounds!");
//if(selectedIndex >= menuItems.size())
// selectedIndex = 0;
S32 size = menuItems.size();
for(S32 i = 0; i < size; i++)
{
S32 y = yStart + (i - ((i < firstItemInCol2) ? 0 : firstItemInCol2)) * height;
S32 Column_Width = DisplayManager::getScreenInfo()->getGameCanvasWidth() / 2 - horizMargin;
S32 xPos = (menuItems[i].column - 1) * Column_Width + horizMargin * 2;
if(selectedIndex == i) // Highlight selected item
RenderUtils::drawFilledRect(xPos - horizMargin, y,
xPos + Column_Width - horizMargin, y + height + 1,
Colors::blue40, Colors::blue);
// Draw item text
mGL->glColor(Colors::cyan);
RenderUtils::drawString(xPos, y + offset, 15, menuItems[i].text);
xPos += Column_Width * 14 / 20;
if(mChangingItem == i)
{
mGL->glColor(Colors::red);
RenderUtils::drawString(xPos, y + offset + 1, 13, "Press Key or Button");
}
else
{
bool dupe = isDuplicate(i, menuItems);
const Color *color = dupe ? &Colors::red : NULL;
JoystickRender::renderControllerButton(F32(xPos), F32(y + offset),
Joystick::SelectedPresetIndex, getInputCode(mGameSettings, menuItems[i].primaryControl), color);
}
}
S32 yPos = yStart + maxMenuItemsInAnyCol * height + 10;
// Draw the help string
mGL->glColor(Colors::green);
RenderUtils::drawCenteredString(yPos, 15, menuItems[selectedIndex].helpString.c_str());
yPos += 20;
// Draw some suggestions
mGL->glColor(Colors::yellow);
if(getGame()->getInputMode() == InputModeJoystick)
RenderUtils::drawCenteredString(yPos, 15, "HINT: You will be using the left joystick to steer, the right to fire");
else
RenderUtils::drawCenteredString(yPos, 15, "HINT: You will be using the mouse to aim, so make good use of your mouse buttons");
if(errorMsgTimer.getCurrent())
{
yPos += 20;
F32 alpha = 1.0;
if(errorMsgTimer.getCurrent() < 1000)
alpha = (F32) errorMsgTimer.getCurrent() / 1000;
mGL->glColor(Colors::red, alpha);
RenderUtils::drawCenteredString(yPos, 15, errorMsg.c_str());
}
}