Пример #1
0
// Draw the control.
void Slider::draw(void)
{
    // Draw the background.
	drawBackground();

    // Draw the thumb.
    if(!(isClear(m_thumbColor) && isClear(m_thumbOutlineColor))) {
        float relativePosition = 0.0;
        if(m_maxValue != m_minValue) {
            relativePosition = ((float)(m_position-m_minValue)) / (m_maxValue-m_minValue);
        }

        Rect thumbRect = m_rect;
        if(m_vertical) {
            // Vertical thumb.
            thumbRect.size.height = m_thumbLength * m_rect.size.height;
            thumbRect.origin.y += (1.0 - relativePosition) * (m_rect.size.height-thumbRect.size.height);
        } else {
            // Horizontal thumb.
            thumbRect.size.width = m_thumbLength * m_rect.size.width;
            thumbRect.origin.x += relativePosition * (m_rect.size.width-thumbRect.size.width);
        }

        m_thumbRect = thumbRect;            // Want to save away the bigger version for mouse hits.
        thumbRect.inset(Size(.01,.01));
        drawRect(thumbRect, m_thumbColor);
        drawRectOutline(thumbRect, m_thumbOutlineColor, 1.0);
    }
}
Пример #2
0
//Draw window background.
void Window::drawBackground( void )
{
    m_texture.draw( m_rect );
    if ( !isClear( m_color ) )
        drawRect( m_rect, m_color );
    if ( !isClear( m_outlineColor ) )
        drawRectOutline( m_rect, m_outlineColor, m_outlineWidth );
}
Пример #3
0
FiltrationResult AbstractValue::filter(Graph& graph, const StructureSet& other)
{
    if (isClear())
        return FiltrationOK;
    
    // FIXME: This could be optimized for the common case of m_type not
    // having structures, array modes, or a specific value.
    // https://bugs.webkit.org/show_bug.cgi?id=109663
    
    m_type &= other.speculationFromStructures();
    m_arrayModes &= other.arrayModesFromStructures();
    m_currentKnownStructure.filter(other);
    
    // It's possible that prior to the above two statements we had (Foo, TOP), where
    // Foo is a SpeculatedType that is disjoint with the passed StructureSet. In that
    // case, we will now have (None, [someStructure]). In general, we need to make
    // sure that new information gleaned from the SpeculatedType needs to be fed back
    // into the information gleaned from the StructureSet.
    m_currentKnownStructure.filter(m_type);
    
    if (m_currentKnownStructure.hasSingleton())
        setFuturePossibleStructure(graph, m_currentKnownStructure.singleton());
        
    filterArrayModesByType();
    filterValueByType();
    return normalizeClarity();
}
Пример #4
0
void MapGenerator::placeDoodad(int x, int y)
{

	sf::IntRect doodadRect(x, y, 1, 1);

	if (isClear(doodadRect))
	{
		std::vector<sf::Vector2i> doodadSprites;
		doodadSprites.push_back(sf::Vector2i(2, 4));
		doodadSprites.push_back(sf::Vector2i(3, 4));
		doodadSprites.push_back(sf::Vector2i(3, 5));
		doodadSprites.push_back(sf::Vector2i(3, 6));
		doodadSprites.push_back(sf::Vector2i(3, 8));
		doodadSprites.push_back(sf::Vector2i(4, 8));

		if (x >= 0 && x < mMap.getWidth() &&
			y >= 0 && y < mMap.getHeight())
		{
			mMap[x][y].setSprite(1, doodadSprites[std::rand() % doodadSprites.size()]);
			mMap[x][y].setCollidable(true);
			mMap[x][y].setOccupied(true);
		}

	}
	

}
Пример #5
0
bool AbstractValue::mergeOSREntryValue(Graph& graph, JSValue value)
{
    AbstractValue oldMe = *this;
    
    if (isClear()) {
        FrozenValue* frozenValue = graph.freeze(value);
        if (frozenValue->pointsToHeap()) {
            m_structure = frozenValue->structure();
            m_arrayModes = asArrayModes(frozenValue->structure()->indexingType());
        } else {
            m_structure.clear();
            m_arrayModes = 0;
        }
        
        m_type = speculationFromValue(value);
        m_value = value;
    } else {
        mergeSpeculation(m_type, speculationFromValue(value));
        if (!!value && value.isCell()) {
            Structure* structure = value.asCell()->structure();
            graph.registerStructure(structure);
            mergeArrayModes(m_arrayModes, asArrayModes(structure->indexingType()));
            m_structure.merge(StructureSet(structure));
        }
        if (m_value != value)
            m_value = JSValue();
    }
    
    checkConsistency();
    assertIsRegistered(graph);
    
    return oldMe != *this;
}
Пример #6
0
//displays every game enemy in the current level
void displayGameEnemies(){
    attron(COLOR_PAIR(MONSTER_COLOR));
    for(int i=0;i<ENTS;i++)
        if(ISTRUE==isClear(getDist(enemies[i].coords.x,chara.coords.x),
                           getDist(enemies[i].coords.y,chara.coords.y)))
            if(enemies[i].alive==ISTRUE)
                mvaddch(enemies[i].coords.y,enemies[i].coords.x,ENEMY);
    attroff(COLOR_PAIR(MONSTER_COLOR));
}
Пример #7
0
FiltrationResult AbstractValue::filterArrayModes(ArrayModes arrayModes)
{
    ASSERT(arrayModes);
    
    if (isClear())
        return FiltrationOK;
    
    m_type &= SpecCell;
    m_arrayModes &= arrayModes;
    return normalizeClarity();
}
Пример #8
0
// Calculate the thumb colors based on the specified background color.
void Slider::setThumbColorBasedOnColor(const GFXColor& c) {
	if(!isClear(c)) {
		if(isColorLight(c)) {
			// Light color.  Make thumb darker.
			setThumbColor(darkenColor(c,.3), GUI_OPAQUE_WHITE());
		} else {
			// Dark Color.
			setThumbColor(lightenColor(c,.3), GUI_OPAQUE_WHITE());
		}
	}
}
Пример #9
0
FiltrationResult AbstractValue::filter(SpeculatedType type)
{
    if (isClear())
        return FiltrationOK;
    
    if (type == SpecTop)
        return isClear() ? Contradiction : FiltrationOK;
    
    m_type &= type;
    
    // It's possible that prior to this filter() call we had, say, (Final, TOP), and
    // the passed type is Array. At this point we'll have (None, TOP). The best way
    // to ensure that the structure filtering does the right thing is to filter on
    // the new type (None) rather than the one passed (Array).
    m_currentKnownStructure.filter(m_type);
    m_futurePossibleStructure.filter(m_type);
    filterArrayModesByType();
    filterValueByType();
    return normalizeClarity();
}
Пример #10
0
 void solveNQueens(vector<vector<string> > &res, vector<string> &board, int index, int n) {
     if(index == n) {
         res.push_back(board);
         return;
     }
     
     for(int i=0; i<n; i++) {
         if(isClear(board, i, index, n)) {
             board[i][index] = 'Q';
             solveNQueens(res, board, index+1, n);
             board[i][index] = '.';
         }
         
     }
 }
Пример #11
0
//displays the current map
void displayGameMap(){
    for(int yy=0;yy<sizeof(map)/sizeof(char*);yy++)
        for(int xx=0;xx<strlen(map[0]);xx++)
            if(ISTRUE==isClear(getDist(xx,chara.coords.x),getDist(yy,chara.coords.y))){
                if(map[yy][xx]=='.'){
                    attron(COLOR_PAIR(DEFAULT_COLOR));
                    mvaddch(yy,xx,map[yy][xx]);
                    attroff(COLOR_PAIR(DEFAULT_COLOR));
                }else
                    attron(COLOR_PAIR(WALL_COLOR));
                    mvaddch(yy,xx,map[yy][xx]);
                    attroff(COLOR_PAIR(WALL_COLOR));
            }else
                mvaddch(yy,xx,UNKNOWN);
}
Пример #12
0
void AbstractValue::checkConsistency() const
{
    if (!(m_type & SpecCell)) {
        ASSERT(m_currentKnownStructure.isClear());
        ASSERT(m_futurePossibleStructure.isClear());
        ASSERT(!m_arrayModes);
    }
    
    if (isClear())
        ASSERT(!m_value);
    
    if (!!m_value)
        ASSERT(mergeSpeculations(m_type, speculationFromValue(m_value)) == m_type);
    
    // Note that it's possible for a prediction like (Final, []). This really means that
    // the value is bottom and that any code that uses the value is unreachable. But
    // we don't want to get pedantic about this as it would only increase the computational
    // complexity of the code.
}
Пример #13
0
//RETURNS 1 if there are n squares of uncarved rock in direction d, 0 o/w
int
shMapLevel::enoughClearance (int x, int y, shDirection d, int m, int n)
{
    int x1, x2;
    int y1, y2;

    switch (d) {
    case kNorth:
        if (y < 5) return 0;
        x1 = x - n;
        x2 = x + n;
        y1 = y - m;
        y2 = y - 1;
        break;
    case kSouth:
        if (y > mRows - 5) return 0;
        x1 = x - n;
        x2 = x + n;
        y1 = y + 1;
        y2 = y + m;
        break;
    case kEast:
        if (x > mColumns - 6) return 0;
        x1 = x + 1;
        x2 = x + m;
        y1 = y - n;
        y2 = y + n;
        break;
    case kWest:
        if (x < 6) return 0;
        x1 = x - m;
        x2 = x - 1;
        y1 = y - n;
        y2 = y + n;
        break;
    default:
        abort ();
    }
    return isClear (x1, y1, x2, y2);
}
Пример #14
0
void MapGenerator::placeKrimsKrams(int x, int y)
{
	sf::IntRect krimsRect(x, y, 1, 1);

	if (isClear(krimsRect))
	{
		std::vector<sf::Vector2i> krimsSprites;
		krimsSprites.push_back(sf::Vector2i(0, 8));
		krimsSprites.push_back(sf::Vector2i(1, 8));
		krimsSprites.push_back(sf::Vector2i(2, 8));
		krimsSprites.push_back(sf::Vector2i(4, 6));

		if (x >= 0 && x < mMap.getWidth() &&
			y >= 0 && y < mMap.getHeight())
		{
			mMap[x][y].setSprite(1, krimsSprites[std::rand() % krimsSprites.size()]);
			mMap[x][y].setCollidable(false);
			mMap[x][y].setOccupied(true);
		}

	}
}
Пример #15
0
void AbstractValue::checkConsistency() const
{
    if (!(m_type & SpecCell)) {
        ASSERT(m_structure.isClear());
        ASSERT(!m_arrayModes);
    }
    
    if (isClear())
        ASSERT(!m_value);
    
    if (!!m_value) {
        SpeculatedType type = m_type;
        // This relaxes the assertion below a bit, since we don't know the representation of the
        // node.
        if (type & SpecInt52)
            type |= SpecInt52AsDouble;
        ASSERT(mergeSpeculations(type, speculationFromValue(m_value)) == type);
    }
    
    // Note that it's possible for a prediction like (Final, []). This really means that
    // the value is bottom and that any code that uses the value is unreachable. But
    // we don't want to get pedantic about this as it would only increase the computational
    // complexity of the code.
}
Пример #16
0
vector<vector<string> > solveNQueens(int n) {

	vector<vector<string> > res;
    if(n==2 || n == 3 || n <= 0) {
        return res;
    }
	// use 1d vector to store the 
	// index of queens on the row
    vector<int> index(n, -1);
    //initialization
    int k=0;
    index[0] = 0;
    // consider kth row
    while(k >= 0) {

    	if(k < n && index[k] < n) {
    		while(!isClear(index, k)) {
    			index[k]
    		}
    	}
    }


}
Пример #17
0
//aqui recebe uma string e são tratados todos os chars para o proposito do programa
int calcular(char g_char[], pilha *p){

	if( isEnter(g_char[0]) || !isEmpty(p)){
		int i = 0;
		
		while(g_char[i] != '\0'){
			
			//insere o estado dos calculos
			if(!isClear(g_char[i]) && !isConsulta(g_char[i])){
				if(isEmpty(p))
					printf("- ");
				consulta_inversa(p);
				printf("\n");
			}
			
			//se for numero insere na pilha
			if(isNum(g_char[i])){
				insertNum(p, g_char[i] - 48);
				
				//se o char anterior tbm for numero faz calculo para fazer dos 2 um numero
				if(isNum(g_char[i-1] )|| isEnter(g_char[i-1]))
					faz_calculo(p);
				else{
					clear_calc(p);
					if(!RUN_CODES){
						exibeHeader();
						printf("\nErro! Voce deve usar necessariamente \'E\' para informar a entrada de um numero\n");
					}
				}
				i++;
				continue;
			}
			
			//se for um E insere 0 na pilha
			if(isEnter(g_char[i])){
        		insertNum(p, 0);
        		i++;
        		continue;
			}
			
			//se for '-' faz uma subtração
			if(g_char[i] == '-'){
				faz_sub(p);
				i++;
				continue;
			}
			
			//se for '+' faz uma adição
			if(g_char[i] == '+'){
				faz_soma(p);
				i++;
				continue;
			}
			
			//se for '/' faz uma divisão
            if(g_char[i] == '/'){
				faz_div(p);
				i++;
				continue;
			}
			
			//se for '*' faz uma multiplicação
            if(g_char[i] == '*'){
				faz_mult(p);
				i++;
				continue;
			}
			
			//se for '^' faz uma potencia
            if(g_char[i] == '^'){
				faz_pow(p);
				i++;
				continue;
			}
			
			//se for '!' faz um fatorial
            if(g_char[i] == '!'){
				faz_fatorial(p);
				i++;
				continue;
			}
			
			//se for C limpa a pilha
			if(isClear(g_char[i])){
				clear_calc(p);
				if(!RUN_CODES){
					exibeHeader();
					printf("\nPilha Vazia\n");
				}
				i++;
				continue;
			}
			
			//se for V faz uma consulta na pilha
			if(isConsulta(g_char[i]) && strlen(g_char) == 1){
				if(!RUN_CODES)
					consulta(p);
				i++;
			}
				
		}
		if(!isConsulta(g_char[i-1]))
			//consulta que exibe a pilha ao contrario
			consulta_inversa(p);
		if(!RUN_CODES)
			printf("\n");
		return 0;
	}else{
		//se o char indice 0 for V exibe a consulta
		if(isConsulta(g_char[0]))
			if(!RUN_CODES)
				consulta(p);
				
		else{
			//se o char indice 0 for C limpa a pilha
			if(isClear(g_char[0]))
				clear_calc(p);
				
			else
				return 1;
		}
	}
		
	
}
Пример #18
0
int main(void){
/*マス目の確保
	端の一列は空のまま使うので余分に2列多く取る*/
	//MINE_TABLE table[MINE_TABLE_HIGHT + 2][MINE_TABLE_WIDTH + 2];
	MINE_TABLE **table;

	/*マス目メモリ領域確保*/
	table = getMemory(MINE_TABLE_WIDTH,MINE_TABLE_HIGHT);
	/*マス目初期化*/
	init_mine_table(table);
	
	printf("\n座標を入力し、行動を数値で入力して下さい。\n"
			"(q でプログラム終了します。)\n"
			"(r でゲームをリスタートします。)\n");

	while(1){
		/*マス目表示*/
		view_mine_table(table,debug);
		
		/*登録処理*/
		printf("\n(d でデバッグ表示します。)"
			"例:x y no\n"
			"x,y:座標 no:1 めくる 2 フラグ立て\n"
			"-->");
		gets(char_temp);/*文字入力受付*/
		if(strcmp("q",char_temp) == 0){
			printf("終了します。\n");
			return 0;
		}else if(strcmp("d",char_temp) == 0){
			if(debug == 0){
				debug = 1;/*デバッグ表示ON*/
			}else if(debug == 1){
				debug = 0;/*デバッグ表示OFF*/
			}
		}else if(strcmp("r",char_temp) == 0){
			/*ゲーム初期化*/
			init_mine_table(table);
			continue;
		}
		/*入力受付*/
		sscanf(char_temp,"%d %d %d",&y,&x,&no);
		
		/*マス目を開く*/
		if(no == 1){
			if(isBomd(table,x,y)){/*爆弾なら*/
				if(isOpend(table,x,y)){
					printf("そのマスは既に開いています。\n");
				}else{
					gameover();/*ゲームオーバー*/
				}
			}else{
				if(isOpend(table,x,y)){
					/*既に開かれている数字の周りを自動で開く*/
					open_mine_table_execute(table,x,y);
				}else{
					/*未開拓領域を開く*/
					open_mine_table(table,x,y);
				}
			}
		}else if(no == 2){
			if(isOpend(table,x,y)){
				printf("そのマスは既に開いています。\n");
			}else{
				/*印をつける*/
				check_flag_mine_table(table,x,y);
			}
		}

		if(isClear(table)){/*クリアーなら*/
			gameclear();
		}
	}
	return(0);
}
Пример #19
0
// Draw the picker
void Picker::draw(void)
{
    // If we need to change the displayed cells, do that first.
    if(m_needRecalcDisplay) {
        recalcDisplay();
    }

    // Draw the background.
    drawBackground();

    const float cellHeight = totalCellHeight();

    // This is the current cell rect.  Start with control rect and adjust y.
    Rect rect(m_rect);
    rect.origin.y += m_rect.size.height - cellHeight;
    rect.size.height = cellHeight;

    for(int i=m_scrollPosition; i<m_displayCells.size() && rect.origin.y > m_rect.origin.y; i++) {
        DisplayCell& display = m_displayCells[i];
        const PickerCell* cell = display.cell;      // Get the next cell.

        // Figure background and text color.
        GFXColor backgroundColor = GUI_CLEAR;
        GFXColor textColor = cell->textColor();
        if(cell == m_selectedCell) {
            // Selected state more important than highlighted state.
            backgroundColor = m_selectionColor;
            if(isClear(textColor)) textColor = m_selectionTextColor;
        }
        // Selection color might be clear, or might be highlighted cell.
        if(isClear(backgroundColor) && cell == m_highlightedCell) {
            // Highlighted cell.
            backgroundColor = m_highlightColor;
            if(isClear(textColor)) textColor = m_highlightTextColor;
        }
        if(!isClear(backgroundColor)) {
            drawRect(rect, backgroundColor);
        }
        // If we haven't got a text color yet, use the control's color.
        if(isClear(textColor)) textColor = m_textColor;

        // Include indent in drawing rect.
        // Indent is based on cell height.
        const float indentPerLevel = m_displayCells[i].level * cellHeight * CHILD_INDENT_FACTOR;
        Rect drawRect = rect;
        drawRect.inset(m_textMargins);
        drawRect.origin.x += indentPerLevel;
        drawRect.size.width -= indentPerLevel;

        // Paint the text.
        // There is a PaintText object in each DisplayCell so that we don't have to re-layout the text
        //  all the time.  This code should be smarter about only setting the attributes of the text
        //  object when things change, but that means cell changes need to be communicated back to
        //  this object, and they aren't now.
        display.paintText.setRect(drawRect);
        display.paintText.setText(cell->text());
        display.paintText.setFont(m_font);
        display.paintText.setColor(textColor);
        display.paintText.draw();

        rect.origin.y -= cellHeight;
    }
}
Пример #20
0
/*=======================================
ウィンドウプロシージャ処理
コールバック関数
メッセージを受け取りそれぞれ処理する
---------------------------------------*/
LRESULT CALLBACK WndProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam){
	/*マス目配列アドレス情報*/
	MINE_TABLE **table;
	HDC hdc;
	PAINTSTRUCT ps;
	int id = 0;
	int difficulty = DIFFICULT;/*初期難易度*/
	int size_x,size_y;
	
	switch(msg){
	case WM_DESTROY:
		PostQuitMessage(0);
		break;
	case WM_CLOSE:
		id = MessageBox(hWnd,
			(LPCSTR)"終了しますか",
			(LPCSTR)"終了確認",
			MB_OKCANCEL | MB_ICONQUESTION);
		if(id == IDOK)
			DestroyWindow(hWnd);
		return (0L);
	case WM_PAINT:
		hdc	=	BeginPaint(hWnd,&ps);
		ShowMyBMP(hWnd,hdc);
		TextOut(hdc,50,50,"まいんすい〜ぱ",14);
		SetBkMode(hdc,TRANSPARENT);
		SetTextColor(hdc,RGB(255,0,0));
		TextOut(hdc,50,100,"池田健太 試作",14);
		EndPaint(hWnd,&ps);
		break;
	case WM_COMMAND:
		switch(LOWORD(wParam)){
		case EXIT_GAME:
			SendMessage(hWnd,WM_CLOSE,wParam,lParam);
		case HELP:
			MessageBox(hWnd, 
				(LPCSTR)"ヘルプが押されました", 
				(LPCSTR)"test", 
				MB_OK);
			break;
		case VERSION_INFO:
			MessageBox(hWnd, 
				(LPCSTR)"バージョン情報が押されました", 
				(LPCSTR)"About",
				MB_OK);
			break;
		case NEW_GAME:
			/*難易度ごとにテーブルサイズを指定*/
			if(difficulty == DIFFICULT_EASY){
				size_x = size_y = EASY_TABLE_SIZE;
			}else if(difficulty == DIFFICULT_NORMAL){
				size_x = size_y = NORMAL_TABLE_SIZE;
			}else if(difficulty == DIFFICULT_HARD){
				size_x = size_y = HARD_TABLE_SIZE;
			}
			/*マス目メモリ領域確保*/
			table = getMemory(size_x,size_y);
			/*マス目初期化*/
			init_mine_table(table);
			
			/*
			printf("\n座標を入力し、行動を数値で入力して下さい。\n"
				"(q でプログラム終了します。)\n"
				"(r でゲームをリスタートします。)\n");
			*/

			while(1){
				break;/*デバッグ用*/

				/*マス目表示*/
				//view_mine_table(table,debug);
				
				/*登録処理*/
				/*printf("\n(d でデバッグ表示します。)"
					"例:x y no\n"
					"x,y:座標 no:1 めくる 2 フラグ立て\n"
					"-->");
					*/
				//gets(char_temp);/*文字入力受付*/
				if(strcmp("q",char_temp) == 0){
					printf("終了します。\n");
					return 0;
				}else if(strcmp("d",char_temp) == 0){
					if(debug == 0){
						debug = 1;/*デバッグ表示ON*/
					}else if(debug == 1){
						debug = 0;/*デバッグ表示OFF*/
					}
				}else if(strcmp("r",char_temp) == 0){
					/*ゲーム初期化*/
					init_mine_table(table);
					continue;
				}
				/*入力受付*/
				//sscanf(char_temp,"%d %d %d",&y,&x,&no);
				
				/*マス目を開く*/
				if(no == 1){
					if(isBomd(table,x,y)){/*爆弾なら*/
						if(isOpend(table,x,y)){
							printf("そのマスは既に開いています。\n");
						}else{
							gameover();/*ゲームオーバー*/
						}
					}else{
						if(isOpend(table,x,y)){
							/*既に開かれている数字の周りを自動で開く*/
							open_mine_table_execute(table,x,y);
						}else{
							/*未開拓領域を開く*/
							open_mine_table(table,x,y);
						}
					}
				}else if(no == 2){
					if(isOpend(table,x,y)){
						printf("そのマスは既に開いています。\n");
					}else{
						/*印をつける*/
						check_flag_mine_table(table,x,y);
					}
				}
				
				if(isClear(table)){/*クリアーなら*/
					gameclear();
				}
			}
			return(0);
		}
		break;
		default:
			return(DefWindowProc(hWnd,msg,wParam,lParam));
	}
	return (0L);
}
Пример #21
0
void MapGenerator::placeTree(int x, int y)
{
	int width = std::rand() % 4 + 2;
	int height = std::rand() % 4 + 3;


	sf::IntRect treeRect(x - 1, y - 1, width, height );
	
	if (isClear(treeRect))
	{
		//first make all tiles occupied:
		for (int i = treeRect.left; i < treeRect.left + treeRect.width; i++)
		{
			for (int j = treeRect.top; j < treeRect.top + treeRect.height; j++)
			{
				int tileX = i;
				int tileY = j;

				if (tileX >= 0 && tileX < mMap.getWidth() &&
					tileY >= 0 && tileY < mMap.getHeight())
				{
					mMap[tileX][tileY].setOccupied(true);
				}
			}
		}

		//then place corners:
		if (treeRect.left >= 0 && treeRect.left < mMap.getWidth() &&
			treeRect.top >= 0 && treeRect.top < mMap.getHeight())
		{
			mMap[treeRect.left][treeRect.top].setSprite(2, sf::Vector2i(3, 0));
			mMap[treeRect.left][treeRect.top].setCollidable(false);
		}

		if (treeRect.left + treeRect.width - 1 >= 0 && treeRect.left + treeRect.width - 1 < mMap.getWidth() &&
			treeRect.top >= 0 && treeRect.top < mMap.getHeight())
		{
			mMap[treeRect.left + treeRect.width - 1][treeRect.top].setSprite(2, sf::Vector2i(4, 0));
			mMap[treeRect.left + treeRect.width - 1][treeRect.top].setCollidable(false);
		}

		if (treeRect.left >= 0 && treeRect.left < mMap.getWidth() &&
			treeRect.top + treeRect.height - 1 >= 0 && treeRect.top + treeRect.height - 1 < mMap.getHeight())
		{
			mMap[treeRect.left][treeRect.top + treeRect.height - 1].setSprite(2, sf::Vector2i(3, 1));
			mMap[treeRect.left][treeRect.top + treeRect.height - 1].setCollidable(false);
		}

		if (treeRect.left + treeRect.width - 1 >= 0 && treeRect.left + treeRect.width - 1 < mMap.getWidth() &&
			treeRect.top + treeRect.height - 1 >= 0 && treeRect.top + treeRect.height - 1 < mMap.getHeight())
		{
			mMap[treeRect.left + treeRect.width - 1][treeRect.top + treeRect.height - 1].setSprite(2, sf::Vector2i(4, 1));
			mMap[treeRect.left + treeRect.width - 1][treeRect.top + treeRect.height - 1].setCollidable(false);
		}

		//place mid leaves! THERE ARE NONE!
		for (int i = treeRect.left + 1; i < treeRect.left + treeRect.width - 1; i++)
		{
			for (int j = treeRect.top + 1; j < treeRect.top + treeRect.height - 1; j++)
			{
				int tileX = i;
				int tileY = j;

				if (tileX >= 0 && tileX < mMap.getWidth() &&
					tileY >= 0 && tileY < mMap.getHeight())
				{
					mMap[tileX][tileY].setSprite(2, sf::Vector2i(4, 5));
					mMap[tileX][tileY].setCollidable(false);
				}
			}
		}

		//NOW PLACE EDGES! OVER AND OTHER MOTHERFATHERS!
		for (int i = treeRect.left + 1; i < treeRect.left + treeRect.width - 1; i++)
		{
			int tileX = i;
			int tileY = treeRect.top;

			if (tileX >= 0 && tileX < mMap.getWidth() &&
				tileY >= 0 && tileY < mMap.getHeight())
			{
				mMap[tileX][tileY].setSprite(2, sf::Vector2i(3, 2));
				mMap[tileX][tileY].setCollidable(false);
			}
		}
		
		for (int i = treeRect.left + 1; i < treeRect.left + treeRect.width - 1; i++)
		{
			int tileX = i;
			int tileY = treeRect.top + treeRect.height - 1;

			if (tileX >= 0 && tileX < mMap.getWidth() &&
				tileY >= 0 && tileY < mMap.getHeight())
			{
				mMap[tileX][tileY].setSprite(2, sf::Vector2i(4, 3));
				mMap[tileX][tileY].setCollidable(false);
			}
		}
		
		for (int i = treeRect.top + 1; i < treeRect.top + treeRect.height - 1; i++)
		{
			int tileX = treeRect.left;
			int tileY = i;

			if (tileX >= 0 && tileX < mMap.getWidth() &&
				tileY >= 0 && tileY < mMap.getHeight())
			{
				mMap[tileX][tileY].setSprite(2, sf::Vector2i(4, 2));
				mMap[tileX][tileY].setCollidable(false);
			}
		}

		for (int i = treeRect.top + 1; i < treeRect.top + treeRect.height - 1; i++)
		{
			int tileX = treeRect.left + treeRect.width - 1;
			int tileY = i;

			if (tileX >= 0 && tileX < mMap.getWidth() &&
				tileY >= 0 && tileY < mMap.getHeight())
			{
				mMap[tileX][tileY].setSprite(2, sf::Vector2i(4, 4));
				mMap[tileX][tileY].setCollidable(false);
			}
		}
		
		//BUT BEFORE WE LEAVE: PLACE DA F*****G TRUNK SON!
		for (int i = treeRect.left + 1; i < treeRect.left + treeRect.width - 1; i++)
		{
			int tileX = i;
			int tileY = treeRect.top + treeRect.height;

			if (tileX >= 0 && tileX < mMap.getWidth() &&
				tileY >= 0 && tileY < mMap.getHeight())
			{
				mMap[tileX][tileY].setSprite(1, sf::Vector2i(2, 3));
				mMap[tileX][tileY].setCollidable(true);
			}
		}

		//EDGES
		if (treeRect.left >= 0 && treeRect.left < mMap.getWidth() &&
			treeRect.top + treeRect.height >= 0 && treeRect.top + treeRect.height < mMap.getHeight())
		{
			mMap[treeRect.left][treeRect.top + treeRect.height].setSprite(1, sf::Vector2i(1, 3));
			mMap[treeRect.left][treeRect.top + treeRect.height].setCollidable(true);
		}

		if (treeRect.left + treeRect.width - 1 >= 0 && treeRect.left + treeRect.width - 1 < mMap.getWidth() &&
			treeRect.top + treeRect.height >= 0 && treeRect.top + treeRect.height < mMap.getHeight())
		{
			mMap[treeRect.left + treeRect.width - 1][treeRect.top + treeRect.height].setSprite(1, sf::Vector2i(3, 3));
			mMap[treeRect.left + treeRect.width - 1][treeRect.top + treeRect.height].setCollidable(true);
		}

	}
}
Пример #22
0
void MapGenerator::placeHut(int x, int y)
{
	int width = std::rand() % 3 + 3;
	int height = std::rand() % 3 + 3;


	sf::IntRect hutRect(x - width / 2, y - height / 2, width, height );
	
	if (width % 2 == 0)
		x-=1;
	if (height % 2 == 0)
		y-=1;
	
	if (isClear(hutRect))
	{
		//first make all tiles occupied
		for (int i = hutRect.left; i < hutRect.left + hutRect.width; i++)
		{
			for (int j = hutRect.top; j < hutRect.top + hutRect.height; j++)
			{
				int tileX = i;
				int tileY = j;

				if (tileX >= 0 && tileX < mMap.getWidth() &&
					tileY >= 0 && tileY < mMap.getHeight())
				{
					mMap[tileX][tileY].setOccupied(true);
				}
			}
		}

		//then place corners:
		if (hutRect.left >= 0 && hutRect.left < mMap.getWidth() &&
			hutRect.top >= 0 && hutRect.top < mMap.getHeight())
		{
			mMap[hutRect.left][hutRect.top].setSprite(2, sf::Vector2i(0, 0));
			mMap[hutRect.left][hutRect.top].setCollidable(false);
		}

		if (hutRect.left + hutRect.width - 1 >= 0 && hutRect.left + hutRect.width - 1 < mMap.getWidth() &&
			hutRect.top >= 0 && hutRect.top < mMap.getHeight())
		{
			mMap[hutRect.left + hutRect.width - 1][hutRect.top].setSprite(2, sf::Vector2i(2, 0));
			mMap[hutRect.left + hutRect.width - 1][hutRect.top].setCollidable(false);
		}

		if (hutRect.left >= 0 && hutRect.left < mMap.getWidth() &&
			hutRect.top + hutRect.height - 1 >= 0 && hutRect.top + hutRect.height - 1 < mMap.getHeight())
		{
			mMap[hutRect.left][hutRect.top + hutRect.height - 1].setSprite(1, sf::Vector2i(0, 2));
			mMap[hutRect.left][hutRect.top + hutRect.height - 1].setCollidable(true);
		}

		if (hutRect.left + hutRect.width - 1 >= 0 && hutRect.left + hutRect.width - 1 < mMap.getWidth() &&
			hutRect.top + hutRect.height - 1 >= 0 && hutRect.top + hutRect.height - 1 < mMap.getHeight())
		{
			mMap[hutRect.left + hutRect.width - 1][hutRect.top + hutRect.height - 1].setSprite(1, sf::Vector2i(2, 2));
			mMap[hutRect.left + hutRect.width - 1][hutRect.top + hutRect.height - 1].setCollidable(true);
		}
		
		//place roof!
		for (int i = hutRect.left + 1; i < hutRect.left + hutRect.width - 1; i++)
		{
			for (int j = hutRect.top + 1; j < hutRect.top + hutRect.height - 1; j++)
			{
				int tileX = i;
				int tileY = j;

				if (tileX >= 0 && tileX < mMap.getWidth() &&
					tileY >= 0 && tileY < mMap.getHeight())
				{
					mMap[tileX][tileY].setSprite(2, sf::Vector2i(0, 3));
					mMap[tileX][tileY].setCollidable(true);
				}
			}
		}
		
		//then place chimney!
		if (x >= 0 && x < mMap.getWidth() &&
			y >= 0 && y < mMap.getHeight())
		{
			mMap[x][y].setSprite(2, sf::Vector2i(1, 1));
			mMap[x][y].setCollidable(true);
		}

		
		//NOW PLACE WALLS! OVER AND OUT MOTHERFAKKARS!
		for (int i = hutRect.left + 1; i < hutRect.left + hutRect.width - 1; i++)
		{
			int tileX = i;
			int tileY = hutRect.top;

			if (tileX >= 0 && tileX < mMap.getWidth() &&
				tileY >= 0 && tileY < mMap.getHeight())
			{
				mMap[tileX][tileY].setSprite(2, sf::Vector2i(1, 0));
				mMap[tileX][tileY].setCollidable(false);
			}
		}

		for (int i = hutRect.left + 1; i < hutRect.left + hutRect.width - 1; i++)
		{
			int tileX = i;
			int tileY = hutRect.top + hutRect.height - 1;

			if (tileX >= 0 && tileX < mMap.getWidth() &&
				tileY >= 0 && tileY < mMap.getHeight())
			{
				mMap[tileX][tileY].setSprite(1, sf::Vector2i(1, 2));
				mMap[tileX][tileY].setCollidable(true);
			}
		}

		for (int i = hutRect.top + 1; i < hutRect.top + hutRect.height - 1; i++)
		{
			int tileX = hutRect.left;
			int tileY = i;

			if (tileX >= 0 && tileX < mMap.getWidth() &&
				tileY >= 0 && tileY < mMap.getHeight())
			{
				mMap[tileX][tileY].setSprite(1, sf::Vector2i(0, 1));
				mMap[tileX][tileY].setCollidable(true);
			}
		}

		for (int i = hutRect.top + 1; i < hutRect.top + hutRect.height - 1; i++)
		{
			int tileX = hutRect.left + hutRect.width - 1;
			int tileY = i;

			if (tileX >= 0 && tileX < mMap.getWidth() &&
				tileY >= 0 && tileY < mMap.getHeight())
			{
				mMap[tileX][tileY].setSprite(1, sf::Vector2i(2, 1));
				mMap[tileX][tileY].setCollidable(true);
			}
		}

		//BUT FIRST PLACE DA F*****G DOOR!
		if (x >= 0 && x < mMap.getWidth() &&
			hutRect.top + hutRect.height - 1 >= 0 && hutRect.top + hutRect.height - 1 < mMap.getHeight())
		{
			mMap[x][hutRect.top + hutRect.height - 1].setSprite(1, sf::Vector2i(0, 4));
			mMap[x][hutRect.top + hutRect.height - 1].setCollidable(true);
		}

	}
}
Пример #23
0
//------------------------------------------------------------------------------
void
Game::removePiece()
{
    if ( ! isClear() )
    {
        return;
    }
    m_replay[m_num][0] = m_index;
    m_replay[m_num][1] = m_rotate;
    m_replay[m_num][2] = m_row;
    m_replay[m_num][3] = m_col;
    m_num += 1;
    for ( int x = 0; x < 4; ++x )
    {
        for ( int y = 0; y < 4; ++y )
        {
            if ( ! m_piece[x][y] )
            {
                continue;
            }
            m_buffer[m_col + x - 3][m_row + y - 3] = false;
        }
    }
    for ( int y = 19; y > 0; --y )
    {
        int count( 0 );
        for ( int x = 0; x < 10; ++x )
        {
            if ( m_buffer[x][y] )
            {
                break;
            }
            ++count;
        }
        if ( count < 10 )
        {
            continue;
        }
        for ( int x = 0; x < 10; ++x )
        {
            for ( int i = y; i > 0; --i )
            {
                m_buffer[x][i] = m_buffer[x][i-1];
            }
        }
    }
    int count( 0 );
    for ( int x = 0; x < 10; ++x )
    {
        for ( int y = 0; y < 20; ++y )
        {
            m_arena[x][y] = m_buffer[x][y];
            if ( m_arena[x][y] )
            {
                count += 1;
            }
        }
    }
    if ( count == 0 )
    {
        m_replaying = true;
        m_row = 1;
        clearArena();
    }
}
Пример #24
0
//RETURNS: # of doors
int
shMapLevel::buildRoomOrElRoom (int sx, int sy, int ey)
{
    int ex;
    int x;
    int y;
    int ndoors = 0;
    int doortries = 0;
    int ra = 0 == RNG (20);

    for (ex = sx + 2; ex < mColumns; ex++) {
        if ((ex > sx + 4) and (0 == RNG(7))) {
            /* check for nearby hallway */
            if (isClear (ex, sy, mColumns, ey)) {
                do {
                    --sx; --ex;
                } while (isClear (sx, sy, sx, ey));
                ++sx;
                break;
            }

            while (1) {
                if (RNG (2)) {
                    if (isClear (sx, ey, ex, ey)) {
                        ey++; sy++;
                        if (ey >= mRows) {
                            return -1;
                        }
                    }
                    else {
                        break;
                    }
                }
                else if (isClear (ex, sy, ex, ey)) {
                    ex++; sx++;
                }
                else {
                    break;
                }
            }
        }
        if (!isClear (ex, sy, ex, ey - 1)) {
            break;
        }
    }

    for (x = sx + 1; x < ex -1; x++) {
        for (y = sy + 1; y < ey -1; y++) {
            SETSQ (x, y, kFloor);
            if (ra) {
                SETSQFLAG (x, y, kRadioactive);
            }
        }
    }

    /* add walls */
    for (x = sx + 1; x < ex - 1; x++) {
        SETSQ (x, sy, kHWall);
        SETSQ (x, ey - 1, kHWall);
    }
    for (y = sy + 1; y < ey - 1; y++) {
        SETSQ (sx, y, kVWall);
        SETSQ (ex - 1, y, kVWall);
    }
    SETSQ (sx, sy, kNWCorner);
    SETSQ (sx, ey - 1, kSWCorner);
    SETSQ (ex - 1, sy, kNECorner);
    SETSQ (ex - 1, ey - 1, kSECorner);

    /* add doors */

    while ((doortries < 122) and
           (ndoors < 1 + RNG (ex - sx) / 4))
    {
        if (RNG (2)) {
            x = RNG (sx + 1, ex - 2);
            y = RNG (2) ? sy : ey -1;
            if (TESTSQ (x, y - 1, kFloor) and
                TESTSQ (x, y + 1, kFloor))
            {
                SETSQ (x, y, kFloor);
                addDoor (x, y, 0 == RNG (4), 0 == RNG (5), -1);
                ++ndoors;
            }
        }
        else {
            y = RNG (sy + 1, ey - 1);
            x = RNG (2) ? sx : ex - 1;
            if (TESTSQ (x - 1, y, kFloor) and
                TESTSQ (x + 1, y, kFloor))
            {
                SETSQ (x, y, kFloor);
                addDoor (x, y, 0 == RNG (4), 0 == RNG (5), -1);
                ++ndoors;
            }
        }
        ++doortries;
    }

    return ndoors;
}
Пример #25
0
/**
* Deallocate the chunk of memory at address ptr
* 
* @param ptr The address of the chunk to deallocate
*
* @return None
*/
void free(void* ptr) {

	Run* run_ptr=NULL, *prev_run_ptr=NULL;
	int bit_index=0;
	int ret=0;
	LargeChunk *lc_ptr=NULL, *prev_ptr=NULL;

	// Check to see if ptr is a large chunk
	if(((unsigned int)ptr & 0xfff) == 0 && largeChunks != NULL) {
		for(lc_ptr = largeChunks; lc_ptr!= NULL && lc_ptr->memory != ptr; prev_ptr=lc_ptr, lc_ptr=lc_ptr->next);
	}
	
	// If ptr is a large chunk
	if (lc_ptr != NULL) {
		if((ret = deallocate(ptr, lc_ptr->size)))
			_terminate(4);
		lc_ptr->memory = 0;
		lc_ptr->size = 0;
		if(prev_ptr == NULL)
			largeChunks = lc_ptr->next;
		else
			prev_ptr->next = lc_ptr->next;
		free(lc_ptr);
		return;
	}

	// Find the run the ptr belongs to
	int j;
	for(j=0; j<POOL_NUM; j++) {
		int found=0;
		for(run_ptr = pool[j], prev_run_ptr=NULL; run_ptr != NULL; prev_run_ptr=run_ptr, run_ptr=run_ptr->next) {
			if(run_ptr->memory == ((void *)((unsigned int)ptr & 0xfffff000))) {
				found=1;
				break;
			}
		}
		if(found)
			break;
	}

	// No run found
	if(run_ptr == NULL)
		return;

	// Free and zero chunk
	bit_index = (ptr - run_ptr->memory) / run_ptr->size;
	clearBit(run_ptr->bitmap, bit_index);
	//bzero(ptr, run_ptr->size);

	// Deallocate empty run
	if(isClear(run_ptr->bitmap)) {
		if(prev_run_ptr == NULL)
			pool[j] = run_ptr->next;
		else
			prev_run_ptr->next = run_ptr->next;
		if((ret = deallocate(run_ptr->memory, _SC_PAGESIZE)))
			_terminate(4);
		clearRun(run_ptr);
		if((ret = deallocate(run_ptr, _SC_PAGESIZE)))
			_terminate(4);
		run_ptr = NULL;

	}


}