コード例 #1
0
ファイル: matrix_test.c プロジェクト: javajigi/my-slipp
void testMatrixMulti(void)
{
	int **matrixA, **matrixB;
	int	**matrixResult;
	int	rowNumOfA, colNumOfA;
	int	rowNumOfB, colNumOfB;
	int rowNumOfR, colNumOfR;

	rowNumOfA = 2;
	colNumOfA = 3;

	rowNumOfB = 3;
	colNumOfB = 2;

	matrixA = generateMatrix(rowNumOfA, colNumOfA);
	matrixB = generateMatrix(rowNumOfB, colNumOfB);

	matrixResult = make2DArray(rowNumOfA, colNumOfA);

	printf("----------- test: matrix multiplication ------------------\n");
	if(!matrixMulti(matrixResult, matrixA, rowNumOfA, colNumOfA, matrixB, rowNumOfB, colNumOfB)) {
		printf("matrixA\n");
		printMatrix(matrixA, rowNumOfA, colNumOfA);

		printf("matrixB\n");
		printMatrix(matrixB, rowNumOfB, colNumOfB);

		printf("matrixResult = matrixA x matrixB\n");
		rowNumOfR = rowNumOfA;
		colNumOfR = colNumOfB;
		printMatrix(matrixResult, rowNumOfR, colNumOfR);	
	}
	else
		printf("Fail to matrix multiplication\n");
}
コード例 #2
0
ファイル: matrix_test.c プロジェクト: javajigi/my-slipp
void testMatrixSum(void)
{
	int **matrixA, **matrixB;
	int	**matrixResult;
	int	rowNum, colNum;

	rowNum = colNum = 3;

	matrixA = generateMatrix(rowNum, colNum);
	matrixB = generateMatrix(rowNum, colNum);

	matrixResult = make2DArray(rowNum, colNum);

	matrixSum(matrixResult, matrixA, matrixB, rowNum, colNum);

	printf("----------- test: matrix addition ------------------\n");

	printf("matrixA\n");
	printMatrix(matrixA, rowNum, colNum);

	printf("matrixB\n");
	printMatrix(matrixB, rowNum, colNum);

	printf("matrixResult = matrixA + matrixB\n");
	printMatrix(matrixResult, rowNum, colNum);

}
コード例 #3
0
ファイル: array_test.c プロジェクト: javajigi/my-slipp
void testMake2DArray(void)
{
	int	**twoDimArray;
	int	rowNum, colNum;
	int	rowIdx, colIdx;

	printf("start testMake2DArray()\n");

	rowNum = 5;
	colNum = 5;

	twoDimArray = make2DArray(rowNum, colNum);

	for(rowIdx = 0; rowIdx < rowNum; rowIdx++)
		for(colIdx = 0; colIdx < colNum; colIdx++) 
			twoDimArray[rowIdx][colIdx] = rand() % 10;
	
	print2DArray(twoDimArray, rowNum, colNum);

	return;
}
コード例 #4
0
ファイル: array_test.c プロジェクト: nhnponyo/test1
//
// 테스트 함수: 동적 할당된 2차원 배열 메모리의 함수 전달 및 출력
//
void testMake2DArray(void)
{
	int	**twoDimArray;
	int	rowNum, colNum;
	int	rowIdx, colIdx;

	printf("start testMake2DArray()\n");

	// 행과 열의 개수 지정
	rowNum = 5;
	colNum = 5;
	// 지정된 크기의 matrix 메모리 생성
	twoDimArray = make2DArray(rowNum, colNum);

	// matrix의 각 원소에 임의의 값 저장
	for(rowIdx = 0; rowIdx < rowNum; rowIdx++)
		for(colIdx = 0; colIdx < colNum; colIdx++) 
			twoDimArray[rowIdx][colIdx] = rand() % 10;
	
	print2DArray(twoDimArray, rowNum, colNum);

	return;
}
コード例 #5
0
ファイル: matrix_test.c プロジェクト: javajigi/my-slipp
void testMatrixTranspose(void)
{
	int **matrixA;
	int	**matrixAT;
	int	rowNumOfA, colNumOfA;
	int rowNumOfAT, colNumOfAT;

	rowNumOfA = 2;
	colNumOfA = 3;
	matrixA = generateMatrix(rowNumOfA, colNumOfA);

	rowNumOfAT = colNumOfA;
	colNumOfAT = rowNumOfA;
	matrixAT = make2DArray(rowNumOfAT, colNumOfAT);

	printf("----------- test: matrix transpose ------------------\n");
	matrixTranspose(matrixAT, matrixA, rowNumOfA, colNumOfA);

	printf("matrixA\n");
	printMatrix(matrixA, rowNumOfA, colNumOfA);

	printf("matrixAT\n");
	printMatrix(matrixAT, rowNumOfAT, colNumOfAT);		
}
コード例 #6
0
void tetrisSinglePlayer(bool** ledArray) {
  /*Setting values of the global variables for Tetris:*/
  TOP_MARGIN = 0.0;
  BOT_MARGIN = 0.0;
  LEFT_MARGIN = 26.0;
  RIGHT_MARGIN = 26.0;
  BOT_END = ARRAY_HEIGHT - BOT_MARGIN - 1.0;
  RIGHT_END = ARRAY_WIDTH - RIGHT_MARGIN - 1.0;

  /*Tetris-specific constants:*/
  const int PIECE_WIDTH = 8; /*Must be evenly divisible by 4*/
  const int SQUARE_WIDTH = PIECE_WIDTH / 4;
  const int LEFT_BORDER = 2; /*Should be a multiple of SQUARE_WIDTH*/
  const int RIGHT_BORDER = 2;
  const int TOP_BORDER = 0;
  const int BOT_BORDER = 2;
  const int INIT_X = LEFT_MARGIN + (RIGHT_END - LEFT_MARGIN - PIECE_WIDTH) / 2 + 1;
  const int INIT_Y = TOP_BORDER;
  srand(time(NULL));

  /*"Bag" of upcoming piece types: ("double" indicating two sets)*/
  int* doubleBag = make1DArray(14);
  refillBag(doubleBag, true);

  /*Tetris-specific variables:*/
  float curX = INIT_X;
  float curY = INIT_Y;
  float projX = curX;
  float projY = curY;
  float shadY = curY;
  int curType = pluckBag(doubleBag);
  int pieceOrien = 1; /*1-4 corresponds to north, east, south, west*/
  int score = 0;
  int input = 0;
  int timer = 1;
  int dropTime = 15; /*Should be > 1; may be decreased for difficulty, but decreasing it might also reduce responsiveness*/
  int garbageLines = 0;

  /*Solid borders:*/
  drawCheckerboard(ledArray, TOP_MARGIN, LEFT_MARGIN, BOT_END - TOP_MARGIN + 1, LEFT_BORDER);
  drawCheckerboard(ledArray, TOP_MARGIN, RIGHT_END + 1 - RIGHT_BORDER, BOT_END - TOP_MARGIN + 1, RIGHT_BORDER);
  drawCheckerboard(ledArray, TOP_MARGIN, LEFT_MARGIN, TOP_BORDER, RIGHT_END - LEFT_MARGIN + 1);
  drawCheckerboard(ledArray, BOT_END + 1 - BOT_BORDER, LEFT_MARGIN, BOT_BORDER, RIGHT_END - LEFT_MARGIN + 1);

  /*Current piece state and its next projected state:*/
  bool** curPiece = make2DArray(PIECE_WIDTH, PIECE_WIDTH);
  importPiece(curPiece, curType, pieceOrien, PIECE_WIDTH);
  bool** projPiece = make2DArray(PIECE_WIDTH, PIECE_WIDTH);
  copyPiece(projPiece, curPiece, PIECE_WIDTH);
  while(checkOverlap(ledArray, projPiece, curPiece, shadY + SQUARE_WIDTH, curX, curY, curX, PIECE_WIDTH, SQUARE_WIDTH, false) == 0) {
    shadY += SQUARE_WIDTH;
  }

  while(1) {
    drawPiece(ledArray, curPiece, curType, false, curY, curX, PIECE_WIDTH);
    drawShadow(ledArray, curPiece, curType, false, shadY, curX, PIECE_WIDTH);
    drawPiece(ledArray, projPiece, curType, true, projY, projX, PIECE_WIDTH);
    copyPiece(curPiece, projPiece, PIECE_WIDTH);
    curX = projX;
    curY = projY;
    shadY = curY;
    while(checkOverlap(ledArray, projPiece, curPiece, shadY + SQUARE_WIDTH, curX, curY, curX, PIECE_WIDTH, SQUARE_WIDTH, false) == 0) {
      shadY += SQUARE_WIDTH;
    }
    drawShadow(ledArray, curPiece, curType, true, shadY, curX, PIECE_WIDTH);
    frameTest(ledArray, TOP_MARGIN, LEFT_MARGIN, BOT_MARGIN, RIGHT_MARGIN );
    input = getLeftInput();
    if (input == 1) { /*Hard drop*/
      while(checkOverlap(ledArray, projPiece, curPiece, projY + SQUARE_WIDTH, projX, curY, curX, PIECE_WIDTH, SQUARE_WIDTH, false) == 0) {
        projY += SQUARE_WIDTH;
        drawPiece(ledArray, curPiece, curType, false, curY, curX, PIECE_WIDTH);
        copyPiece(curPiece, projPiece, PIECE_WIDTH);
        curX = projX;
        curY = projY;
        drawPiece(ledArray, curPiece, curType, true, curY, curX, PIECE_WIDTH);
        frameTest(ledArray, TOP_MARGIN, LEFT_MARGIN, BOT_MARGIN, RIGHT_MARGIN );
      }
      score = checkLines(ledArray, LEFT_MARGIN + LEFT_BORDER, RIGHT_END - RIGHT_BORDER, BOT_END - BOT_BORDER - garbageLines * SQUARE_WIDTH, TOP_MARGIN + TOP_BORDER, score, curY, PIECE_WIDTH, SQUARE_WIDTH);
        /*
        if(some measure of time has passed) {
          if (addGarbage(ledArray, LEFT_MARGIN + LEFT_BORDER, RIGHT_END - RIGHT_BORDER, BOT_END - BOT_BORDER, TOP_MARGIN + TOP_BORDER, SQUARE_WIDTH)) {
            break; //Game loss
          }
          else {
            garbageLines++;
          }
        }
        */
      projX = INIT_X;
      projY = INIT_Y;
      curX = projX;
      curY = projY;
      shadY = curY;
      curType = pluckBag(doubleBag);
      pieceOrien = 1;
      timer = 1;
      importPiece(curPiece, curType, pieceOrien, PIECE_WIDTH);
      copyPiece(projPiece, curPiece, PIECE_WIDTH);
      if(checkOverlap(ledArray, projPiece, curPiece, projY, projX, curY, curX, PIECE_WIDTH, SQUARE_WIDTH, true)) {
        break; /*Game loss*/
      }
    }
    else if(input == 5 || timer++ % dropTime == 0) { /*Soft drop*/
      if(checkOverlap(ledArray, projPiece, curPiece, projY + SQUARE_WIDTH, projX, curY, curX, PIECE_WIDTH, SQUARE_WIDTH, false)) {
        score = checkLines(ledArray, LEFT_MARGIN + LEFT_BORDER, RIGHT_END - RIGHT_BORDER, BOT_END - BOT_BORDER - garbageLines * SQUARE_WIDTH, TOP_MARGIN + TOP_BORDER, score, curY, PIECE_WIDTH, SQUARE_WIDTH);
        /*
        if(some measure of time has passed) {
          if (addGarbage(ledArray, LEFT_MARGIN + LEFT_BORDER, RIGHT_END - RIGHT_BORDER, BOT_END - BOT_BORDER, TOP_MARGIN + TOP_BORDER, SQUARE_WIDTH)) {
            break; //Game loss
          }
          else {
            garbageLines++;
          }
        }
        */
        projX = INIT_X;
        projY = INIT_Y;
        curX = projX;
        curY = projY;
        shadY = curY;
        curType = pluckBag(doubleBag);
        pieceOrien = 1;
        timer = 1;
        importPiece(curPiece, curType, pieceOrien, PIECE_WIDTH);
        copyPiece(projPiece, curPiece, PIECE_WIDTH);
        if(checkOverlap(ledArray, projPiece, curPiece, projY, projX, curY, curX, PIECE_WIDTH, SQUARE_WIDTH, true)) {
          break; /*Game loss*/
        }
      }
      else {
        projY += SQUARE_WIDTH;
        timer = 1;
      }
    }
    else if(input == 9) { /*Spin clockwise*/
      pieceOrien++;
      if(pieceOrien > 4) {
        pieceOrien -= 4;
      }
      importPiece(projPiece, curType, pieceOrien, PIECE_WIDTH);
      if(checkOverlap(ledArray, projPiece, curPiece, projY, projX, curY, curX, PIECE_WIDTH, SQUARE_WIDTH, false)) {
        if(!checkOverlap(ledArray, projPiece, curPiece, projY, projX  + SQUARE_WIDTH, curY, curX, PIECE_WIDTH, SQUARE_WIDTH, false)) {
          projX += SQUARE_WIDTH;
        }
        else if(curType == 0 && !checkOverlap(ledArray, projPiece, curPiece, projY, projX + 2 * SQUARE_WIDTH, curY, curX, PIECE_WIDTH, SQUARE_WIDTH, false)) {
          projX += 2 * SQUARE_WIDTH;
        }
        else if(!checkOverlap(ledArray, projPiece, curPiece, projY, projX - SQUARE_WIDTH, curY, curX, PIECE_WIDTH, SQUARE_WIDTH, false)) {
          projX -= SQUARE_WIDTH;
        }
        else if(curType == 0 && !checkOverlap(ledArray, projPiece, curPiece, projY, projX - 2 * SQUARE_WIDTH, curY, curX, PIECE_WIDTH, SQUARE_WIDTH, false)) {
          projX -= 2 * SQUARE_WIDTH;
        }
        else {
          pieceOrien--;
          if(pieceOrien < 1) {
            pieceOrien += 4;
          }
          importPiece(projPiece, curType, pieceOrien, PIECE_WIDTH);
        }
      }
    }
    else if(input == 10) { /*Spin counterclockwise*/
      pieceOrien--;
      if(pieceOrien < 1) {
        pieceOrien += 4;
      }
      importPiece(projPiece, curType, pieceOrien, PIECE_WIDTH);
      if(checkOverlap(ledArray, projPiece, curPiece, projY, projX, curY, curX, PIECE_WIDTH, SQUARE_WIDTH, false)) {
        if(!checkOverlap(ledArray, projPiece, curPiece, projY, projX  + SQUARE_WIDTH, curY, curX, PIECE_WIDTH, SQUARE_WIDTH, false)) {
          projX += SQUARE_WIDTH;
        }
        else if(curType == 0 && !checkOverlap(ledArray, projPiece, curPiece, projY, projX + 2 * SQUARE_WIDTH, curY, curX, PIECE_WIDTH, SQUARE_WIDTH, false)) {
          projX += 2 * SQUARE_WIDTH;
        }
        else if(!checkOverlap(ledArray, projPiece, curPiece, projY, projX - SQUARE_WIDTH, curY, curX, PIECE_WIDTH, SQUARE_WIDTH, false)) {
          projX -= SQUARE_WIDTH;
        }
        else if(curType == 0 && !checkOverlap(ledArray, projPiece, curPiece, projY, projX - 2 * SQUARE_WIDTH, curY, curX, PIECE_WIDTH, SQUARE_WIDTH, false)) {
          projX -= 2 * SQUARE_WIDTH;
        }
        else {
          pieceOrien++;
          if(pieceOrien > 4) {
            pieceOrien -= 4;
          }
          importPiece(projPiece, curType, pieceOrien, PIECE_WIDTH);
        }
      }
    }
    else if(input == 3) { /*Move right*/
      if(checkOverlap(ledArray, projPiece, curPiece, projY, projX + SQUARE_WIDTH, curY, curX, PIECE_WIDTH, SQUARE_WIDTH, false) == 0) {
        projX += SQUARE_WIDTH;
      }
    }
    else if(input == 7) { /*Move left*/
      if(checkOverlap(ledArray, projPiece, curPiece, projY, projX - SQUARE_WIDTH, curY, curX, PIECE_WIDTH, SQUARE_WIDTH, false) == 0) {
        projX -= SQUARE_WIDTH;
      }
    }
  }
  drawPiece(ledArray, curPiece, curType, true, curY, curX, PIECE_WIDTH);
  frameTest(ledArray, TOP_MARGIN, LEFT_MARGIN, BOT_MARGIN, RIGHT_MARGIN );
  free(doubleBag);
  free2DArray(curPiece, PIECE_WIDTH);
  free2DArray(projPiece, PIECE_WIDTH);
  return;
}