bool Game::init()
{
if (!Layer::init()) {
return false;
}
auto size = Director::getInstance()->getVisibleSize();
auto layerColor = LayerColor::create(Color4B(200, 150, 100, 200));
addChild(layerColor);
//标题
auto titleLabel = Label::createWithTTF("2048 Game","fonts/Marker Felt.ttf",70);
titleLabel->setColor(Color3B(200, 250, 100));
titleLabel->setPosition(Vec2(size.width/2,size.height/2+550));
auto letter = titleLabel->getLetter(1);
auto letter1 = titleLabel->getLetter(3);
auto rote = RepeatForever::create(RotateBy::create(1, 180));
auto rote1 = RepeatForever::create(RotateBy::create(1, 180));
letter->runAction(rote);
letter1->runAction(rote1);//设置字体旋转
addChild(titleLabel);
auto Label = Label::createWithTTF("score:", "fonts/arial.ttf", 50);
Label->setColor(Color3B::BLUE);
Label->setPosition(Vec2(80,size.height/2+450));
addChild(Label);
char t[10];
score=0;
sprintf(t,"%d",score);
scoreLabel = Label::createWithTTF(t, "fonts/Marker Felt.ttf", 40);
scoreLabel->setColor(Color3B::BLUE);
scoreLabel->setPosition(Vec2(170,size.height/2+450));
addChild(scoreLabel);
auto newGame = Label::createWithTTF("new Game", "fonts/Marker Felt.ttf",50);
newGame->setColor(Color3B::GRAY);
newGame->setPosition(Vec2(110,size.height/2+380));
addChild(newGame);
auto bt = Button::create("buttonreplay.png");
bt->setPosition(Vec2(260,size.height/2+380));
bt->addClickEventListener(CC_CALLBACK_0(Game::restart, this));
addChild(bt);
auto listener = EventListenerTouchOneByOne::create();
listener->onTouchBegan=CC_CALLBACK_2(Game::onTouchBegan, this)
;
listener->onTouchEnded=CC_CALLBACK_2(Game::onTouchEnded, this);
_eventDispatcher->addEventListenerWithSceneGraphPriority(listener, this);
createCard();
createCardNumber();
createCardNumber();
return true;
}
LabelFNTSpriteActions::LabelFNTSpriteActions()
{
_time = 0;
// Upper Label
auto label = Label::createWithBMFont("fonts/bitmapFontTest.fnt", "Bitmap Font Atlas");
addChild(label);
auto s = Director::getInstance()->getWinSize();
label->setPosition( Point(s.width/2, s.height/2) );
label->setAnchorPoint( Point::ANCHOR_MIDDLE );
auto BChar = (Sprite*) label->getLetter(0);
auto FChar = (Sprite*) label->getLetter(7);
auto AChar = (Sprite*) label->getLetter(12);
auto rotate = RotateBy::create(2, 360);
auto rot_4ever = RepeatForever::create(rotate);
auto scale = ScaleBy::create(2, 1.5f);
auto scale_back = scale->reverse();
auto scale_seq = Sequence::create(scale, scale_back,NULL);
auto scale_4ever = RepeatForever::create(scale_seq);
auto jump = JumpBy::create(0.5f, Point::ZERO, 60, 1);
auto jump_4ever = RepeatForever::create(jump);
auto fade_out = FadeOut::create(1);
auto fade_in = FadeIn::create(1);
auto seq = Sequence::create(fade_out, fade_in, NULL);
auto fade_4ever = RepeatForever::create(seq);
BChar->runAction(rot_4ever);
BChar->runAction(scale_4ever);
FChar->runAction(jump_4ever);
AChar->runAction(fade_4ever);
// Bottom Label
auto label2 = Label::createWithBMFont("fonts/bitmapFontTest.fnt", "00.0");
addChild(label2, 0, kTagBitmapAtlas2);
label2->setPosition( Point(s.width/2.0f, 80) );
label2->setAnchorPoint( Point::ANCHOR_MIDDLE );
auto lastChar = (Sprite*) label2->getLetter(3);
lastChar->runAction( rot_4ever->clone() );
schedule( schedule_selector(LabelFNTSpriteActions::step), 0.1f);
}
void TextFieldTTF::update(float delta)
{
if (_cursorEnabled && _isAttachWithIME)
{
_cursorShowingTime -= delta;
if (_cursorShowingTime < -CURSOR_TIME_SHOW_HIDE)
{
_cursorShowingTime = CURSOR_TIME_SHOW_HIDE;
}
// before cursor inserted '\b', need next letter
auto sprite = getLetter((int)_cursorPosition + 1);
if (sprite)
{
if (_cursorShowingTime >= 0.0f)
{
sprite->setOpacity(255);
}
else
{
sprite->setOpacity(0);
}
sprite->setDirty(true);
}
}
}
std::set< std::string > BoggleSolver::giveMeWords(std::string base, Coordinates start, std::set< Coordinates > alreadyUsed) const
{
std::set< std::string > result;
std::set< std::string > otherResult;
base+=getLetter(start.getX(),start.getY());
alreadyUsed.insert(start);
if(base.size()>=MIN_WORD_LENGTH )
{
//Attention, upper != lower+1
std::string upperBound = dictionnary.getUpperBound(base);
if(dictionnary.isValid(base))
result.insert(base);
//Optimisation : si on ne trouve pas base dans le début de upper bound, on peut arreter
if(upperBound.compare(0,base.size(),base)!=0)
return result;
}
std::vector<Coordinates> adj = start.getAdjacent(gridSize-1,gridSize-1);
for(std::vector<Coordinates >::const_iterator it = adj.begin(); it != adj.end();++it)
{
if(alreadyUsed.find(*it)==alreadyUsed.end())
{
otherResult = giveMeWords(base,*it,alreadyUsed);
std::set_union(result.begin(), result.end(), otherResult.begin(), otherResult.end(), std::inserter(result,result.end()));
}
}
return result;
}
GBitmap* GFont::drawOCRBaseImage(uint startRec,uint rowsNum){
string str;
int w=63;
int h=63;
if(startRec==0)startRec++;
GBitmap *tableImg=GBitmap::create(w*20,h*20+20);
//находим нужную букву по idNumber
int step=0,y=0;
//TIME_START
//cout<<"@@@letterCount="<<letterCount()<<" rowsNum="<<rowsNum<<endl;
for(int i=startRec;i<startRec+rowsNum&&i<letterCount();i++){
GLetter *letter=getLetter(i);
//cout_<<"aliKali[0]["<<i<<"]->name="<<letter->name<<" OCRKey="<<letter->OCRKey<<endl;
if(letter->name=="*"){letter->destroy();continue;}
GBitmap *letterImg=letter->drawLetterPict(1);
//GBitmap *letterImg=letter->mask128.unPackMask();
GBitmap *letterImgScale=GBitmap::createScale(letterImg,0.3);
tableImg->drawImg(letterImgScale,w*step+17,y+15);
step++;
if(step==20){
//tableImg->drawImg(blank,w*step-40,y-90);
y+=h;step=0;
}
letterImg->destroy();
letterImgScale->destroy();
}
return tableImg;
}
void Lab1Decryptor::decrypt(const std::vector<ANSIChar> &acv, std::vector<char> &result)
{
result.clear();
std::vector<MorseChar> morseChars(mac.convertANSIToMorse(acv));
for (int i = 0; i < morseChars.size(); i++)
result.push_back(getLetter(morseChars[i]));
}
int Game_functions::checkPos(int number, string letter){
char newLetter;
newLetter = letter[0];
if (grid[number][getLetter(newLetter)]=='.'){
return 0;
} else {
return 1;
}
}
void FontGrid::mousePressEvent(QMouseEvent *e)
{
int letter = getLetter(e->pos());
if(letter < _letterCountH*_letterCountV) {
setLetter(letter);
emit letterClicked(letter);
}
setFocus();
}
const float CCTextureFontPage::getHeight(const char *text, const uint length, const float size) const
{
float maxHeight = 0.0f;
for( uint i=0; i<length; ++i )
{
const Letter *letter = getLetter( text[i] );
if( letter != NULL )
{
maxHeight = MAX( maxHeight, letter->size.height * size );
}
}
return maxHeight;
}
void Player::addToPlaylist(std::string code) {
std::cerr << "<5>Adding " << code << " to queue\n";
mutex.lock();
Audio *letter = getLetter(code);
if(letter) {
queue.push(letter);
} else {
std::cerr << "<4>Could not play '" << code << "'\n";
}
mutex.unlock();
}
Label::Label(TextHAlignment hAlignment /* = TextHAlignment::LEFT */,
TextVAlignment vAlignment /* = TextVAlignment::TOP */)
: _textSprite(nullptr)
, _shadowNode(nullptr)
, _fontAtlas(nullptr)
, _reusedLetter(nullptr)
, _horizontalKernings(nullptr)
{
setAnchorPoint(Vec2::ANCHOR_MIDDLE);
reset();
_hAlignment = hAlignment;
_vAlignment = vAlignment;
#if CC_LABEL_DEBUG_DRAW
_debugDrawNode = DrawNode::create();
addChild(_debugDrawNode);
#endif
_purgeTextureListener = EventListenerCustom::create(FontAtlas::CMD_PURGE_FONTATLAS, [this](EventCustom* event){
if (_fontAtlas && _currentLabelType == LabelType::TTF && event->getUserData() == _fontAtlas)
{
for (auto&& it : _letters)
{
it.second->setTexture(nullptr);
}
_batchNodes.clear();
if (_fontAtlas)
{
FontAtlasCache::releaseFontAtlas(_fontAtlas);
}
}
});
_eventDispatcher->addEventListenerWithFixedPriority(_purgeTextureListener, 1);
_resetTextureListener = EventListenerCustom::create(FontAtlas::CMD_RESET_FONTATLAS, [this](EventCustom* event){
if (_fontAtlas && _currentLabelType == LabelType::TTF && event->getUserData() == _fontAtlas)
{
_fontAtlas = nullptr;
this->setTTFConfig(_fontConfig);
for (auto&& it : _letters)
{
getLetter(it.first);
}
}
});
_eventDispatcher->addEventListenerWithFixedPriority(_resetTextureListener, 2);
}
/**вывод в result HTML rowsNum записей начиная с startRec */
void GFont::drawHTML(uint startRec,int rowsNum,string &result,int mode){
ostringstream str;
if(startRec==0)startRec++;
str<<size()/rowsNum<<endl;
int a=0;
//cout_<< "startRec="<<startRec<<" rowsNum="<<rowsNum<<endl;
for(uint index=startRec;index<startRec+rowsNum;index++){ //cout<<" index="<<index;
GLetter *letter=getLetter(index);
if(letter->name=="*"){letter->destroy();continue;}
//cout_<<"strDict.size="<<strDict.size;
//for(int i=0;i<strDict.len;i++)cout<<" "<<strDict[i]<<endl; cout<<endl;
//str<<"index="<<index<<" name="<<letter->name;
str<<"<div class=\"letterBlock\" title=\""<<letter->name<<"\" id=\""<<index<<"\" onClick=\"editLetterCell('"<<index<<"')\">"<<index<<"</div>\n";
a++;
letter->destroy();
}
result=str.str();
}
GBitmap* GFont::drawOCRBasePict(vector<ulong>&searchResult,int mode){
cout_<<"draw table mode="<<mode<<endl;
string str;
int w=63;
int h=63;
int hMain=h*(int)searchResult.size()/20+h;
GBitmap *tableImg=GBitmap::create(w*20,hMain);
//cout_<<"w="<<tableImg->columns()<<" h="<<tableImg->rows()<<endl;
//GBitmap *blank=GBitmap::create(w*5+40,h+120);
//int in=-1;
//cout_<<"input id="<<idNumber<<" correctionTable.size()="<<correctionTable.size()<<endl;
//находим нужную букву по idNumber
int step=0,y=0;
//TIME_START
//cout_<<"@@@letterCount="<<letterCount();
for(int i=0;i<searchResult.size();i++){
GLetter *letter=getLetter(searchResult[i]);
//cout_<<"aliKali[0]["<<i<<"]->name="<<letter->name<<" OCRKey="<<letter->OCRKey<<endl;
if(letter->name=="*"||letter->name==""){letter->destroy();continue;}
GBitmap *letterImg=letter->drawLetterPict(1);
//GBitmap *letterImg=letter->mask128.unPackMask();
GBitmap *letterImgScale=GBitmap::createScale(letterImg,0.3);
tableImg->drawImg(letterImgScale,w*step+17,y+15);
step++;
if(step==20){
//tableImg->drawImg(blank,w*step-40,y-90);
y+=h;step=0;
}
letterImg->destroy();
letterImgScale->destroy();
}
//TIME_PRINT_
if(mode!=DRAW_BASE){
string path=inputData.data["root"]+"edit/OCRBase.jpg";
((GImageEditor*)inputData.imageEditor)->WriteImageData(tableImg,path,0);
tableImg->destroy();
return 0;
}
return tableImg;
}
// Funcion para obtener la siguiente posicion de escritura.
Page nextPage(char * word) {
char letter = getLetter(word);
int index = getIndex(letter);
Page page;
page.letter = letter;
page.index = 0;
page.number = pages_count[index];
size_t filename_size;
filename_size = snprintf(NULL, 0, "./data/%c.%d", letter, pages_count[index]);
char * filename = (char *)malloc(filename_size + 1);
snprintf(filename, filename_size+1, "./data/%c.%d", letter, pages_count[index]);
// Si el archivo existe y lo podemos leer revisamos la cantidad de lineas
if( access( filename, F_OK ) != -1 ) {
int counter = linesInFile(filename);
page.index = counter;
// Si la cantidad de lineas es igual o mayor al maximo permitido pasamos a la siguiente pagina para el indice
if (counter >= ENTRIESPERPAGE) {
pages_count[index]++;
page.index = 0;
}
page.number = pages_count[index];
filename_size = snprintf(NULL, 0, "./data/%c.%d", letter, page.number);
filename = (char *)malloc(filename_size + 1);
snprintf(filename, filename_size+1, "./data/%c.%d", letter, page.number);
}
page.filename = filename;
return page;
}
/**
* Push a letter to the model of the led matrix
*
* @param matrix Matrix object
* @param string String to push
*/
void matrixPushString(LEDMATRIX* matrix, const char* string)
{
LETTER letter;
unsigned int i;
wchar_t *buffer;
size_t nbChar;
mbstate_t conversionState;
// Prepare conversion
memset(&conversionState, 0, sizeof(mbstate_t));
buffer = (wchar_t*)malloc(sizeof(wchar_t)*strlen(string));
memset(buffer, 0, sizeof(wchar_t)*strlen(string));
// string conversion
mbsrtowcs(buffer, &string, strlen(string), &conversionState);
// scan all wide char
nbChar = wcslen(buffer);
for(i=0; i<nbChar; i++) {
letter = getLetter(buffer[i], matrix->font);
matrixPushLetter(matrix, letter);
}
free(buffer);
}
const float CCTextureFontPage::getWidth(const char *text, const uint length, const float size) const
{
float totalWidth = 0.0f;
for( uint i=0; i<length; ++i )
{
char character = text[i];
if( character == '\n' )
{
break;
}
else
{
const Letter *letter = getLetter( text[i] );
if( letter != NULL )
{
totalWidth += letter->size.width * size;
}
}
}
return totalWidth;
}
void GFont::drawOCRBasePict(uint startRec,uint rowsNum, int mode){
cout_<<"draw table mode="<<mode<<endl;
string str;
int w=63;
int h=63;
int letterPageCount=2000;
if(mode)letterPageCount=20000;
if(startRec==0)startRec++;
GBitmap *tableImg=GBitmap::create(w*20,h*20+20);
//cout_<<"w="<<tableImg->columns()<<" h="<<tableImg->rows()<<endl;
//GBitmap *blank=GBitmap::create(w*5+40,h+120);
//int in=-1;
//cout_<<"input id="<<idNumber<<" correctionTable.size()="<<correctionTable.size()<<endl;
//находим нужную букву по idNumber
int step=0,y=0;
//TIME_START
cout_<<"@@@letterCount="<<letterCount();
for(int i=startRec;i<startRec+rowsNum;i++){
GLetter *letter=getLetter(i);
//cout_<<"aliKali[0]["<<i<<"]->name="<<letter->name<<" OCRKey="<<letter->OCRKey<<endl;
if(letter->name=="*"){letter->destroy();continue;}
GBitmap *letterImg=letter->drawLetterPict(1);
//GBitmap *letterImg=letter->mask128.unPackMask();
GBitmap *letterImgScale=GBitmap::createScale(letterImg,0.3);
tableImg->drawImg(letterImgScale,w*step+17,y+15);
step++;
if(step==20){
//tableImg->drawImg(blank,w*step-40,y-90);
y+=h;step=0;
}
letterImg->destroy();
letterImgScale->destroy();
}
//TIME_PRINT_
string path=inputData.data["root"]+"edit/OCRBase.jpg";
((GImageEditor*)inputData.imageEditor)->WriteImageData(tableImg,path,0);
tableImg->destroy();
}
void TextFieldTTF::setCursorFromPoint(const Vec2 &point, const Camera* camera)
{
if (_cursorEnabled)
{
// Reset Label, no cursor
bool oldIsAttachWithIME = _isAttachWithIME;
_isAttachWithIME = false;
updateCursorDisplayText();
Rect rect;
rect.size = getContentSize();
if (isScreenPointInRect(point, camera, getWorldToNodeTransform(), rect, nullptr))
{
int latterPosition = 0;
for (; latterPosition < _lengthOfString; ++latterPosition)
{
if (_lettersInfo[latterPosition].valid)
{
auto sprite = getLetter(latterPosition);
rect.size = sprite->getContentSize();
if (isScreenPointInRect(point, camera, sprite->getWorldToNodeTransform(), rect, nullptr))
{
setCursorPosition(latterPosition);
break;
}
}
}
if (latterPosition == _lengthOfString)
{
setCursorPosition(latterPosition);
}
}
// Set cursor
_isAttachWithIME = oldIsAttachWithIME;
updateCursorDisplayText();
}
}
void CCTextureFontPage::renderText(const char *text, const uint length,
const float x, const float y,
const bool centeredX, const bool centeredY, const float size) const
{
ASSERT( length < MAX_TEXT_LENGTH );
bindTexturePage();
// Find out our width so we can center the text
CCPoint lineSize[MAX_TEXT_LINES];
CCPoint charSize[MAX_TEXT_LENGTH];
uint numberOfLines = 0;
for( uint i=0; i<length; ++i )
{
const Letter *letter = getLetter( text[i] );
if( letter != NULL )
{
charSize[i].x = letter->size.width * size;
charSize[i].y = letter->size.height * size;
// New line
if( text[i] == 10 )
{
numberOfLines++;
ASSERT( numberOfLines < MAX_TEXT_LINES );
}
lineSize[numberOfLines].x += charSize[i].x;
lineSize[numberOfLines].y = MAX( lineSize[numberOfLines].y, charSize[i].y );
}
}
CCPoint max( lineSize[0].x, lineSize[0].y );
for( uint i=1; i<numberOfLines; ++i )
{
max.x = MAX( max.x, lineSize[i].x );
max.y += lineSize[i].y;
}
CCPoint start = CCPoint( x, y );
if( centeredX )
{
start.x -= max.x * 0.5f;
}
if( centeredY )
{
start.y -= max.y * gEngine->renderer->aspectRatio;
}
CCPoint currentStart = start;
CCPoint currentEnd;
CCSetTexCoords( texCoords );
uint lineNumber = 0;
for( uint i=0; i<length; ++i )
{
const Letter *letter = getLetter( text[i] );
if( letter != NULL )
{
// Calculate end point
currentEnd.x = currentStart.x + charSize[i].x;
currentEnd.y = currentStart.y + charSize[i].y;
// New line
if( text[i] == 10 )
{
currentStart.y += lineSize[lineNumber++].y;
//currentStart.x = lineStart[lineNumber];
}
else
{
texCoords[0] = letter->start.x;
texCoords[1] = letter->start.y;
texCoords[2] = letter->end.x;
texCoords[3] = letter->start.y;
texCoords[4] = letter->start.x;
texCoords[5] = letter->end.y;
texCoords[6] = letter->end.x;
texCoords[7] = letter->end.y;
CCRenderSquare2D( currentStart, currentEnd, false );
currentStart.x += charSize[i].x;
}
}
}
}
void Game_functions::ship_menu(string type, string IP_ADDR){
string input;
cout << "Hi, What's your name?:";
cin >> player_name;
showBoard();
cout << "Nice to meet you " << player_name << endl;
cout << "Say me something to start" << endl;
cin >> input;
cout << "Choose the position for your ships" << endl;
do{
showBoard();
cout << "#1 Aircraft" << endl;
do{
cout << "Letter: ";
cin.clear();
cin.ignore(256, '\n');
cin >> aircraft_letter;
} while(getLetter(aircraft_letter)==666);
do{
cout << "Number: ";
cin.clear();
cin.ignore(256, '\n');
cin >> aircraft_number;
} while(!cin || aircraft_number>24 || aircraft_number<0);
do{
cout << "Pos (v for vertical, h for horizontal):";
cin.clear();
cin.ignore(256, '\n');
cin >> aircraft_pos;
} while(!cin || verPos(aircraft_pos)==false);
} while(canSetShip(getLetter(aircraft_letter), aircraft_number, Aircraft, aircraft_pos)==false);
setShip(Aircraft, aircraft_pos, aircraft_letter, aircraft_number);
do{
showBoard();
cout << "#1 Battleship" << endl;
do{
cout << "Letter: ";
cin.clear();
cin.ignore(256, '\n');
cin >> battleship1_letter;
} while(getLetter(battleship1_letter)==666);
do{
cout << "Number: ";
cin.clear();
cin.ignore(256, '\n');
cin >> battleship1_number;
} while(!cin || battleship1_number>24 || battleship1_number<0);
do{
cout << "Pos (v for vertical, h for horizontal):";
cin.clear();
cin.ignore(256, '\n');
cin >> battleship1_pos;
} while(!cin || verPos(battleship1_pos)==false);
} while(canSetShip(getLetter(battleship1_letter), battleship1_number, Battleship, battleship1_pos)==false);
setShip(Battleship, battleship1_pos, battleship1_letter, battleship1_number);
do{
showBoard();
cout << "#2 Battleship" << endl;
do{
cout << "Letter: ";
cin.clear();
cin.ignore(256, '\n');
cin >> battleship2_letter;
} while(getLetter(battleship2_letter)==666);
do{
cout << "Number: ";
cin.clear();
cin.ignore(256, '\n');
cin >> battleship2_number;
} while(!cin || battleship2_number>24 || battleship2_number<0);
do{
cout << "Pos (v for vertical, h for horizontal):";
cin.clear();
cin.ignore(256, '\n');
cin >> battleship2_pos;
} while(!cin || verPos(battleship2_pos)==false);
} while(canSetShip(getLetter(battleship2_letter), battleship2_number, Battleship, battleship2_pos)==false);
setShip(Battleship, battleship2_pos, battleship2_letter, battleship2_number);
do{
showBoard();
cout << "#1 Cruiser" << endl;
do{
cout << "Letter: ";
cin.clear();
cin.ignore(256, '\n');
cin >> cruiser_letter;
} while(getLetter(cruiser_letter)==666);
do{
cout << "Number: ";
cin.clear();
cin.ignore(256, '\n');
cin >> cruiser_number;
} while(!cin || cruiser_number>24 || cruiser_number<0);
do{
cout << "Pos (v for vertical, h for horizontal):";
cin.clear();
cin.ignore(256, '\n');
cin >> cruiser_pos;
} while(!cin || verPos(cruiser_pos)==false);
} while(canSetShip(getLetter(cruiser_letter), cruiser_number, Cruiser, cruiser_pos)==false);
setShip(Cruiser, cruiser_pos, cruiser_letter, cruiser_number);
do{
showBoard();
cout << "#1 Frigate" << endl;
do{
cout << "Letter: ";
cin.clear();
cin.ignore(256, '\n');
cin >> frigate1_letter;
} while(getLetter(frigate1_letter)==666);
do{
cout << "Number: ";
cin.clear();
cin.ignore(256, '\n');
cin >> frigate1_number;
} while(!cin || frigate1_number>24 || frigate1_number<0);
do{
cout << "Pos (v for vertical, h for horizontal):";
cin.clear();
cin.ignore(256, '\n');
cin >> frigate1_pos;
} while(!cin || verPos(frigate1_pos)==false);
} while(canSetShip(getLetter(frigate1_letter), frigate1_number, Frigate, frigate1_pos)==false);
setShip(Frigate, frigate1_pos, frigate1_letter, frigate1_number);
do{
showBoard();
cout << "#1 Submarine" << endl;
do{
cout << "Letter: ";
cin.clear();
cin.ignore(256, '\n');
cin >> submarine_letter;
} while(getLetter(submarine_letter)==666);
do{
cout << "Number: ";
cin.clear();
cin.ignore(256, '\n');
cin >> submarine_number;
} while(!cin || submarine_number>24 || submarine_number<0);
do{
cout << "Pos (v for vertical, h for horizontal):";
cin.clear();
cin.ignore(256, '\n');
cin >> submarine_pos;
} while(!cin || verPos(submarine_pos)==false);
} while(canSetShip(getLetter(submarine_letter), submarine_number, Submarine, submarine_pos)==false);
setShip(Submarine, submarine_pos, submarine_letter, submarine_number);
clear_screen();
cout << "Let's start the grid..." << endl;
if (type=="server"){
nett.make_server();
} else if(type=="client"){
nett.connect_to_server(IP_ADDR.c_str());
}
}
void Game_functions::killShip(char letter, int number){
grid[number][getLetter(letter)] = 'X';
}
void Game_functions::setShip(int type, char pos, char letter, int number){
char ShipLetter;
switch(type){
case Aircraft:
ShipLetter = 'A';
if (pos=='v'){
grid[number][getLetter(letter)] = ShipLetter;
grid[number+1][getLetter(letter)] = ShipLetter;
grid[number+2][getLetter(letter)] = ShipLetter;
grid[number+3][getLetter(letter)] = ShipLetter;
grid[number+4][getLetter(letter)] = ShipLetter;
} else if (pos=='h'){
grid[number][getLetter(letter)] = ShipLetter;
grid[number][getLetter(letter)+1] = ShipLetter;
grid[number][getLetter(letter)+2] = ShipLetter;
grid[number][getLetter(letter)+3] = ShipLetter;
grid[number][getLetter(letter)+4] = ShipLetter;
}
break;
case Submarine:
ShipLetter = 'S';
if (pos=='v'){
grid[number][getLetter(letter)] = ShipLetter;
grid[number+1][getLetter(letter)] = ShipLetter;
grid[number+2][getLetter(letter)] = ShipLetter;
grid[number+3][getLetter(letter)] = ShipLetter;
} else if (pos=='h'){
grid[number][getLetter(letter)] = ShipLetter;
grid[number][getLetter(letter)+1] = ShipLetter;
grid[number][getLetter(letter)+2] = ShipLetter;
grid[number][getLetter(letter)+3] = ShipLetter;
}
break;
case Frigate:
ShipLetter = 'F';
if (pos=='v'){
grid[number][getLetter(letter)] = ShipLetter;
grid[number+1][getLetter(letter)] = ShipLetter;
} else if (pos=='h'){
grid[number][getLetter(letter)] = ShipLetter;
grid[number][getLetter(letter)+1] = ShipLetter;
}
break;
case Battleship:
ShipLetter = 'B';
if (pos=='v'){
grid[number][getLetter(letter)] = ShipLetter;
grid[number+1][getLetter(letter)] = ShipLetter;
grid[number+2][getLetter(letter)] = ShipLetter;
grid[number+3][getLetter(letter)] = ShipLetter;
} else if (pos=='h'){
grid[number][getLetter(letter)] = ShipLetter;
grid[number][getLetter(letter)+1] = ShipLetter;
grid[number][getLetter(letter)+2] = ShipLetter;
grid[number][getLetter(letter)+3] = ShipLetter;
}
break;
case Cruiser:
ShipLetter = 'C';
if (pos=='v'){
grid[number][getLetter(letter)] = ShipLetter;
grid[number+1][getLetter(letter)] = ShipLetter;
grid[number+2][getLetter(letter)] = ShipLetter;
} else if (pos=='h'){
grid[number][getLetter(letter)] = ShipLetter;
grid[number][getLetter(letter)+1] = ShipLetter;
grid[number][getLetter(letter)+2] = ShipLetter;
}
break;
}
}
// Funcion que maneja las busquedas por valor
void * find(void * input) {
// Obtenemos el indice entregado, con eso buscaremos la informacion necesaria
int indice = (int) input;
pthread_mutex_lock(&instructionsMutex);
Instruction instruccion = instructions[indice];
char * word = (char *) malloc(sizeof(char) * (strlen(instruccion.word) +1));
strcpy(word, instruccion.word);
pthread_mutex_unlock(&instructionsMutex);
char letter = getLetter(word);
int index = getIndex(letter);
// Seteamos la cantidad de workers que necesitaremos
int n_workers = pages_count[index];
// Creamos un arreglo de strings donde guardaremos los archivos que necesitaremos
char ** files = (char **) malloc(sizeof(char *) * n_workers);
size_t filename_size;
// Llenamos el arreglo de strings con los nombres de archivos
int i, k;
for (i = 0; i < n_workers; i++) {
filename_size = snprintf(NULL, 0, "%c.%d", letter, (i+1));
files[i] = (char *)malloc(filename_size + 1);
snprintf(files[i], filename_size+1, "%c.%d", letter, (i +1));
}
int *pthread_ids;
pthread_t *workers;
// Creamos el arreglo de pthread_t para los workers
pthread_ids = (int*) malloc(sizeof(int) * n_workers);
workers = (pthread_t*) malloc(sizeof(pthread_t) * n_workers);
// Levantamos los workers necesarios
for (i = 0;i < n_workers; i++) {
FindObject *C = (FindObject *) malloc(sizeof(FindObject));
C->word = word;
C->filename = files[i];
pthread_ids[i] = pthread_create(&workers[i], NULL, findFromFile, C);
}
// Creamos un arreglo de strings dodne guardaremos los IDs que encontremos
char ** resultIDs;
int numberResults = 0;
size_t indexLength;
// Por cada worker esperamos que vuelva (con un join) y leemos el resultado
for (i = 0; i < n_workers; i++) {
FindObject *m;
pthread_join(workers[i], (void *)&m);
// Si encontramos la palabra:
if (m != NULL && m->n_found > 0) {
// Recorremos el listado de posiciones donde se encontro
for (k = 0; k < m->n_found; k++) {
numberResults++;
// Agrandamos el arreglo de strings y guardamos el ID
resultIDs = (char **) realloc(resultIDs, (sizeof(char *) * numberResults));
indexLength = snprintf(NULL, 0, "%s.%d", m->filename, m->positions[k]);
resultIDs[numberResults -1] = (char *)malloc(indexLength + 1);
snprintf(resultIDs[numberResults -1], indexLength+1, "%s.%d", m->filename, m->positions[k]);
}
}
}
char * message = (char *) malloc(1);
size_t message_size;
if (numberResults) {
// Si encontramos resultados generamos un string con los IDs asociados
message_size = snprintf(NULL, 0, "[FIND] %s: ", word);
message = (char *) realloc(message, message_size + 1);
snprintf(message, message_size+1, "[FIND] %s: ", word);
for (i = 0; i < numberResults; i++) {
message_size = strlen(resultIDs[i]) +2;
message = (char *) realloc(message, (sizeof(char) * (strlen(message) + message_size + 1)));
strcat(message, resultIDs[i]);
strcat(message, ", ");
}
message[(strlen(message) -2)] = '\0';
}
else {
// SI no encontramos resultados generamos un mensaje con la informacion
message_size = snprintf(NULL, 0, "[FIND] No se encontro la palabra: %s", word);
message = (char *)malloc(message_size + 1);
snprintf(message, message_size+1, "[FIND] No se encontro la palabra: %s", word);
}
printMessage(instruccion, message);
return NULL;
}
/* Return 0 for ok, 1 to delete the mail, -1 to stop.
* stop is only meaningful for imap. */
static int presentMail(void)
{
int j, k;
const char *redirect = NULL; /* send mail elsewhere */
char key = 0;
const char *atname = NULL; /* name of file or attachment */
bool delflag = false; /* delete this mail */
bool scanat = false; /* scan for attachments */
int displine;
int stashNumber = -1;
/* clear things out from the last message */
if (lastMailInfo)
freeMailInfo(lastMailInfo);
lastMailInfo = 0;
if (sessionList[1].lw)
cxQuit(1, 2);
cs = 0;
cxSwitch(1, false);
iuReformat(mailstring, mailstring_l, &mailu8, &mailu8_l);
if (mailu8) {
if (!addTextToBuffer((pst) mailu8, mailu8_l, 0, false))
showErrorAbort();
} else {
if (!addTextToBuffer((pst) mailstring, mailstring_l, 0, false))
showErrorAbort();
}
browseCurrentBuffer();
if (!passMail) {
redirect = mailRedirect(lastMailInfo->to,
lastMailInfo->from,
lastMailInfo->reply,
lastMailInfo->subject);
}
if (redirect) {
if (!isimap) {
delflag = true;
key = 'w';
if (*redirect == '-')
++redirect, key = 'u';
if (stringEqual(redirect, "x"))
i_puts(MSG_Junk);
else
printf("> %s\n", redirect);
} else {
if (*redirect == '-')
++redirect;
if (stringEqual(redirect, "x"))
redirect = NULL;
}
}
/* display the next page of mail and get a command from the keyboard */
displine = 1;
paging:
if (!delflag) { /* show next page */
if (displine <= cw->dol) {
for (j = 0; j < 20 && displine <= cw->dol;
++j, ++displine) {
char *showline = (char *)fetchLine(displine, 1);
k = pstLength((pst) showline);
showline[--k] = 0;
printf("%s\n", showline);
nzFree(showline);
}
}
}
/* get key command from user */
key_command:
if (delflag)
goto writeMail;
/* interactive prompt depends on whether there is more text or not */
printf("%c ", displine > cw->dol ? '?' : '*');
fflush(stdout);
key = getLetter((isimap ? "q? nwWuUasd" : "q? nwud"));
printf("\b\b\b");
fflush(stdout);
switch (key) {
case 'q':
i_puts(MSG_Quit);
exit(0);
case 'n':
i_puts(MSG_Next);
goto afterinput;
case 's':
i_puts(MSG_Stop);
goto afterinput;
case 'd':
i_puts(MSG_Delete);
delflag = true;
goto afterinput;
case ' ':
if (displine > cw->dol)
i_puts(MSG_EndMessage);
goto paging;
case '?':
i_puts(isimap ? MSG_ImapReadHelp : MSG_MailHelp);
goto key_command;
case 'a':
key = 'w'; /* this will scan attachments */
scanat = true;
case 'w':
case 'W':
case 'u':
case 'U':
break;
default:
i_puts(MSG_NYI);
goto key_command;
} /* switch */
/* At this point we're saving the mail somewhere. */
writeMail:
if (!isimap || isupper(key))
delflag = true;
atname = 0;
if (!isimap)
atname = redirect;
if (scanat)
goto attachOnly;
saveMail:
if (!atname)
atname = getFileName(MSG_FileName, redirect, false, false);
if (stringEqual(atname, "x"))
goto afterinput;
char exists = fileTypeByName(atname, false);
int fsize; /* file size */
int fh = open(atname, O_WRONLY | O_TEXT | O_CREAT | O_APPEND, 0666);
if (fh < 0) {
i_printf(MSG_NoCreate, atname);
goto saveMail;
}
if (exists)
write(fh,
"======================================================================\n",
71);
if (key == 'u') {
if (write(fh, mailstring, mailstring_l) < mailstring_l) {
badsave:
i_printf(MSG_NoWrite, atname);
close(fh);
goto saveMail;
}
close(fh);
fsize = mailstring_l;
} else {
/* key = w, write the file - if pop then save the original unformatted */
if (!isimap && mailStash) {
char *rmf; /* raw mail file */
int rmfh; /* file handle to same */
/* I want a fairly easy filename, in case I want to go look at the original.
* Not a 30 character message ID that I am forced to cut&paste.
* 4 or 5 digits would be nice.
* So the filename looks like /home/foo/.Trash/rawmail/36921
* I pick the digits randomly.
* Please don't accumulate 100,000 emails before you empty your trash.
* It's good to have a cron job empty the trash early Sunday morning.
*/
k = strlen(mailStash);
rmf = allocMem(k + 12);
/* Try 20 times, then give up. */
for (j = 0; j < 20; ++j) {
int rn = rand() % 100000; /* random number */
sprintf(rmf, "%s/%05d", mailStash, rn);
if (fileTypeByName(rmf, false))
continue;
/* dump the original mail into the file */
rmfh =
open(rmf,
O_WRONLY | O_TEXT | O_CREAT | O_APPEND,
0666);
if (rmfh < 0)
break;
if (write(rmfh, mailstring, mailstring_l) <
mailstring_l) {
close(rmfh);
unlink(rmf);
break;
}
close(rmfh);
/* written successfully, remember the stash number */
stashNumber = rn;
break;
}
}
fsize = 0;
for (j = 1; j <= cw->dol; ++j) {
char *showline = (char *)fetchLine(j,
1);
int len = pstLength((pst)
showline);
if (write(fh, showline, len) < len)
goto badsave;
nzFree(showline);
fsize += len;
} /* loop over lines */
if (stashNumber >= 0) {
char addstash[60];
sprintf(addstash, "\nUnformatted %05d\n", stashNumber);
k = strlen(addstash);
if (write(fh, addstash, k) < k)
goto badsave;
fsize += k;
}
close(fh);
attachOnly:
if (nattach)
writeAttachments(lastMailInfo);
else if (scanat)
i_puts(MSG_NoAttachments);
} /* unformat or format */
if (scanat)
goto afterinput;
/* print "mail saved" message */
i_printf(MSG_MailSaved, fsize);
if (exists)
i_printf(MSG_Appended);
nl();
afterinput:
nzFree(mailstring);
mailstring = 0;
nzFree(mailu8);
mailu8 = 0;
if (delflag)
return 1;
if (key == 's')
return -1;
return 0;
} /* presentMail */
void alphabet::drawChar(char a, int X, int Y, float size, unsigned char R, unsigned char G, unsigned char B, unsigned char alpha){
pixelBoolMatrix pbm = getLetter(a).toPixelBoolMatrix(size);
pbm.draw(X,Y,R,G,B,alpha);
}
void CCTextureFontPage::renderText3D(const char *text, const uint length,
const float x, const float y, const float z,
const float height, const bool centeredX) const
{
#if defined PROFILEON
CCProfiler profile( "CCTextureFontPage::renderText3D()" );
#endif
// TODO: I draw these wrong, please fix me to work with back face culling
glCullFace( GL_FRONT );
ASSERT( length < MAX_TEXT_LENGTH );
bindTexturePage();
// Find out our width so we can center the text
int lineIndex = 0;
CCPoint lineSize[MAX_TEXT_LINES];
static CCPoint charSize[MAX_TEXT_LINES][MAX_TEXT_LENGTH];
int characterIndex = 0;
for( uint i=0; i<length; ++i )
{
char character = text[i];
if( character == '\n' )
{
lineIndex++;
characterIndex = 0;
ASSERT( lineIndex < MAX_TEXT_LINES );
}
else
{
const Letter *letter = getLetter( character );
if( letter != NULL )
{
CCPoint &size = charSize[lineIndex][characterIndex];
size.x = letter->size.width * height;
size.y = letter->size.height * height;
lineSize[lineIndex].x += size.x;
lineSize[lineIndex].y = MAX( lineSize[lineIndex].y, size.y );
characterIndex++;
}
}
}
CCPoint start( x, y );
if( centeredX )
{
start.x -= lineSize[0].x * 0.5f;
}
start.y += lineSize[0].y * 0.5f;
static CCVector3 currentStart, currentEnd;
currentStart.x = start.x;
currentStart.y = start.y;
currentStart.z = -z;
currentEnd.z = z;
CCSetTexCoords( texCoords );
lineIndex = 0;
characterIndex = 0;
for( uint i=0; i<length; ++i )
{
char character = text[i];
if( character == '\n' )
{
currentStart.x = start.x;
currentStart.y -= lineSize[lineIndex].y;
lineIndex++;
characterIndex = 0;
}
else
{
const Letter *letter = getLetter( character );
if( letter != NULL )
{
CCPoint &size = charSize[lineIndex][characterIndex];
// Calculate end point
currentEnd.x = currentStart.x + size.x;
currentEnd.y = currentStart.y - size.y;
texCoords[0] = letter->start.x;
texCoords[1] = letter->start.y;
texCoords[2] = letter->end.x;
texCoords[3] = letter->start.y;
texCoords[4] = letter->start.x;
texCoords[5] = letter->end.y;
texCoords[6] = letter->end.x;
texCoords[7] = letter->end.y;
CCRenderSquare( currentStart, currentEnd );
currentStart.x += size.x;
characterIndex++;
}
}
}
glCullFace( GL_BACK );
}
void ReflowDisplay::displayChars(char * chars, int len) {
displayedDigits[0] = getLetter(chars[0]);
displayedDigits[1] = len > 1 ? getLetter(chars[1]) : 0;
displayedDigits[2] = len > 2 ? getLetter(chars[2]) : 0;
}
Label::Label(FontAtlas *atlas /* = nullptr */, TextHAlignment hAlignment /* = TextHAlignment::LEFT */,
TextVAlignment vAlignment /* = TextVAlignment::TOP */,bool useDistanceField /* = false */,bool useA8Shader /* = false */)
: _isOpacityModifyRGB(false)
, _contentDirty(false)
, _fontAtlas(atlas)
, _textSprite(nullptr)
, _compatibleMode(false)
, _reusedLetter(nullptr)
, _additionalKerning(0.0f)
, _commonLineHeight(0.0f)
, _lineBreakWithoutSpaces(false)
, _horizontalKernings(nullptr)
, _maxLineWidth(0.0f)
, _labelDimensions(Size::ZERO)
, _labelWidth(0.0f)
, _labelHeight(0.0f)
, _hAlignment(hAlignment)
, _vAlignment(vAlignment)
, _currNumLines(-1)
, _fontScale(1.0f)
, _useDistanceField(useDistanceField)
, _useA8Shader(useA8Shader)
, _effectColorF(Color4F::BLACK)
, _uniformEffectColor(0)
, _shadowDirty(false)
, _blendFunc(BlendFunc::ALPHA_PREMULTIPLIED)
, _insideBounds(true)
{
setAnchorPoint(Vec2::ANCHOR_MIDDLE);
reset();
_purgeTextureListener = EventListenerCustom::create(FontAtlas::CMD_PURGE_FONTATLAS, [this](EventCustom* event){
if (_fontAtlas && _currentLabelType == LabelType::TTF && event->getUserData() == _fontAtlas)
{
for (auto it : _letters)
{
it.second->setTexture(nullptr);
}
_batchNodes.clear();
if (_fontAtlas)
{
FontAtlasCache::releaseFontAtlas(_fontAtlas);
}
}
});
_eventDispatcher->addEventListenerWithFixedPriority(_purgeTextureListener, 1);
_resetTextureListener = EventListenerCustom::create(FontAtlas::CMD_RESET_FONTATLAS, [this](EventCustom* event){
if (_fontAtlas && _currentLabelType == LabelType::TTF && event->getUserData() == _fontAtlas)
{
_fontAtlas = nullptr;
this->setTTFConfig(_fontConfig);
for (auto it : _letters)
{
getLetter(it.first);
}
}
});
_eventDispatcher->addEventListenerWithFixedPriority(_resetTextureListener, 2);
}
