Pull to refresh
4
0
Сергей @ZimM

User

Получится, если знать алгоритм генерации рандомных чисел. Тогда можно, сделав несколько роллов, вычислить текущее состояние серверного генератора и предсказывать все дальнейшие серверные результаты.

Навскидку - "Рекомендации" в Пуске, кнопка виджетов в углу

Половину? Увольте, на типичных офисных задачах любой современный антивирус будет незаметен. Не похоже, чтобы ваши пользователи ежедневно, например, Хром компилировали...

Подозреваю, дело просто в том, что Убунта на порядки популярнее чем Арч, потому и проблем на ней репортят больше 🤷‍♂️

По крайней мере, там есть абсолютно штатное, документированное решение. Тогда как "выкинуть WiFi-адаптер и поменять на заведомо совместимый" это, простите, не решение проблемы, а её игнорирование

Доказывает наличие тех самых свистоплясок. Ваш Кэп

Ну так, снимите галочку с удаления файлов из Downloads?.. Это чуть ли не со времен ХР можно было сделать


Скрытый текст

image

Ну, чисто технически, в большинстве случаев это не так. Картинки загружаются, чаще всего, или на IPFS (и тогда они иммутабельны, заменить картинку по ссылке не выйдет, хотя всё еще возможно, что ссылка просто умрет), либо, в более редких случаях — напрямую в блокчейн (и тогда все честно — и заменить никак, и лежать она там будет столько, сколько вообще существует блокчейн).

Кому как. Обновленный Проводник действительно красив, а нативная поддержка не-ZIP архивов так и вовсе манна небесная, ИМХО

Простите, "всего"? 13%\20% прироста CPU\GPU это превосходный результат

Очевидно же, что дело не в результате, а в интересе от самого процесса. За деньги автор бы такое не купил)

tasklist /m "mscor*" покажет вам только те приложения, которые используют оригинальный .NET Framework. Приложения, написанные на современном .NET Core туда не попадут, а это большинство.

Но да, большинство GUI в винде написано на С++, дотнет на моей памяти никогда не использовался...

Все это верно. Но учтите, что это все буквально в результате тупейшего запроса "write an arkanoid game in c++ using sdl". А учитывая, что вы можете этот же список ошибок дать инструменту, и он их исправит - это может быть прекрасной точкой для начала работы

На запрос "write an arkanoid game in c++ using sdl" с первой попытки выдало вот такое. Лично я впечатлен, несмотря на то, что main почему-то реализовало дважды. В остальном - не каждый джун так напишет)

Hidden text
#include <SDL.h>

#include <SDL_image.h>

#include <iostream>

// Constants
const int SCREEN_WIDTH = 640;
const int SCREEN_HEIGHT = 480;
const int BRICK_WIDTH = 60;
const int BRICK_HEIGHT = 20;
const int PADDLE_WIDTH = 80;
const int PADDLE_HEIGHT = 10;
const int BALL_RADIUS = 5;
const int BALL_SPEED = 5;

// Game object classes
class Ball {
  public: Ball(SDL_Texture * texture, int x, int y);
  void update();
  void render(SDL_Renderer * renderer);
  void reset();
  int getX() {
    return m_x;
  }
  int getY() {
    return m_y;
  }
  int getRadius() {
    return BALL_RADIUS;
  }
  private: int m_x,
  m_y;
  int m_vx,
  m_vy;
  SDL_Texture * m_texture;
};

class Paddle {
  public: Paddle(SDL_Texture * texture, int x, int y);
  void update();
  void render(SDL_Renderer * renderer);
  int getX() {
    return m_x;
  }
  int getY() {
    return m_y;
  }
  int getWidth() {
    return PADDLE_WIDTH;
  }
  private: int m_x,
  m_y;
  int m_vx;
  SDL_Texture * m_texture;
};

class Brick {
  public: Brick(SDL_Texture * texture, int x, int y);
  void render(SDL_Renderer * renderer);
  bool isDestroyed() {
    return m_destroyed;
  }
  void destroy() {
    m_destroyed = true;
  }
  int getX() {
    return m_x;
  }
  int getY() {
    return m_y;
  }
  int getWidth() {
    return BRICK_WIDTH;
  }
  int getHeight() {
    return BRICK_HEIGHT;
  }
  private: int m_x,
  m_y;
  bool m_destroyed;
  SDL_Texture * m_texture;
};

// Helper functions
bool checkCollision(Ball ball, Paddle paddle);
bool checkCollision(Ball ball, Brick brick);

// Main function
int main(int argc, char ** argv) {
  // Initialize SDL
  if (SDL_Init(SDL_INIT_VIDEO) != 0) {
    std::cout << "SDL_Init error: " << SDL_GetError() << std::endl;
    return 1;
  }
  // Create the window and renderer
  SDL_Window * window = SDL_CreateWindow("Arkanoid", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, SCREEN_WIDTH, SCREEN_HEIGHT, 0);
  if (!window) {
    std::cout << "SDL_CreateWindow error: " << SDL_GetError() << std::endl;
    return 1;
  }
  SDL_Renderer * renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
  if (!renderer) {
    std::cout << "SDL_CreateRenderer error: " << SDL_GetError() << std::endl;
    return 1;
  }
  // Load textures
  SDL_Surface * ballSurface = IMG_Load("ball.png");
  SDL_Texture * ballTexture = SDL_CreateTextureFromSurface(renderer, ballSurface);
  SDL_FreeSurface(ballSurface);
  SDL_Surface * paddleSurface = IMG_Load("paddle.png");
  SDL_Texture * paddleTexture = SDL_CreateTextureFromSurface(renderer, paddleSurface);
  SDL_FreeSurface(paddleSurface);
  SDL_Surface * brickSurface = IMG_Load("brick.png");
  SDL_Texture * brickTexture = SDL_CreateTextureFromSurface(renderer, brickSurface);
  SDL_FreeSurface(brickSurface);
  // Initialize game objects
  Ball ball(ballTexture, SCREEN_WIDTH / 2, SCREEN_HEIGHT - PADDLE_HEIGHT - BALL_RADIUS);
  Paddle paddle(paddleTexture, SCREEN_WIDTH / 2 - PADDLE_WIDTH / 2, SCREEN_HEIGHT - PADDLE_HEIGHT);
  Brick bricks[6][10];
  for (int i = 0; i < 6; i++) {
    for (int j = 0; j < 10; j++) {
      bricks[i][j] = Brick(brickTexture, j * (BRICK_WIDTH + 2) + 1, i * (BRICK_HEIGHT + 2) + 1);
    }
  }
  // Game loop
  bool quit = false;
  while (!quit) {
    // Handle events
    SDL_Event event;
    while (SDL_PollEvent( & event)) {
      if (event.type == SDL_QUIT) {
        quit = true;
      } else if (event.type == SDL_KEYDOWN) {
        switch (event.key.keysym.sym) {
        case SDLK_LEFT:
          paddle.moveLeft();
          break;
        case SDLK_RIGHT:
          paddle.moveRight();
          break;
        }
      }
    }
    // Update game objects
    ball.update();
    paddle.update();
    for (int i = 0; i < 6; i++) {
      for (int j = 0; j < 10; j++) {
        if (checkCollision(ball, bricks[i][j]) && !bricks[i][j].isDestroyed()) {
          ball.reverseY();
          bricks[i][j].destroy();
        }
      }
    }
    if (checkCollision(ball, paddle)) {
      ball.reverseY();
    }
    // Render game objects
    SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
    SDL_RenderClear(renderer);
    ball.render(renderer);
    paddle.render(renderer);
    for (int i = 0; i < 6; i++) {
      for (int j = 0; j < 10; j++) {
        if (!bricks[i][j].isDestroyed()) {
          bricks[i][j].render(renderer);
        }
      }
    }
    SDL_RenderPresent(renderer);
  }
  // Clean up
  SDL_DestroyTexture(ballTexture);
  SDL_DestroyTexture(paddleTexture);
  SDL_DestroyTexture(brickTexture);
  SDL_DestroyRenderer(renderer);
  SDL_DestroyWindow(window);
  SDL_Quit();
  return 0;

}

// Ball implementation
Ball::Ball(SDL_Texture * texture, int x, int y) {
  m_texture = texture;
  m_x = x;
  m_y = y;
  m_vx = BALL_SPEED;
  m_vy = -BALL_SPEED;
}

void Ball::update() {
  m_x += m_vx;
  m_y += m_vy;
  if (m_x < BALL_RADIUS || m_x > SCREEN_WIDTH - BALL_RADIUS) {
    reverseX();
  }
  if (m_y < BALL_RADIUS) {
    reverseY();
  }
  if (m_y > SCREEN_HEIGHT - PADDLE_HEIGHT - BALL_RADIUS) {
    if (m_x > paddle.getX() && m_x < paddle.getX() + PADDLE_WIDTH) {
      m_y = SCREEN_HEIGHT - PADDLE_HEIGHT - BALL_RADIUS;
      reverseY();
    } else {
      // Ball is out of bounds, reset position and velocity
      m_x = SCREEN_WIDTH / 2;
      m_y = SCREEN_HEIGHT - PADDLE_HEIGHT - BALL_RADIUS;
      m_vx = BALL_SPEED;
      m_vy = -BALL_SPEED;
    }
  }
}

void Ball::render(SDL_Renderer * renderer) {
  SDL_Rect rect = {
    m_x - BALL_RADIUS,
    m_y - BALL_RADIUS,
    BALL_RADIUS * 2,
    BALL_RADIUS * 2
  };
  SDL_RenderCopy(renderer, m_texture, NULL, & rect);
}

void Ball::reverseX() {
  m_vx = -m_vx;
}

void Ball::reverseY() {
  m_vy = -m_vy;
}

// Paddle implementation
Paddle::Paddle(SDL_Texture * texture, int x, int y) {
  m_texture = texture;
  m_x = x;
  m_y = y;
}

void Paddle::moveLeft() {
  m_x -= PADDLE_SPEED;
  if (m_x < 0) {
    m_x = 0;
  }
}

void Paddle::moveRight() {
  m_x += PADDLE_SPEED;
  if (m_x > SCREEN_WIDTH - PADDLE_WIDTH) {
    m_x = SCREEN_WIDTH - PADDLE_WIDTH;
  }
}

void Paddle::update() {

}

void Paddle::render(SDL_Renderer * renderer) {
  SDL_Rect rect = {
    m_x,
    m_y,
    PADDLE_WIDTH,
    PADDLE_HEIGHT
  };
  SDL_RenderCopy(renderer, m_texture, NULL, & rect);
}

// Brick implementation
Brick::Brick(SDL_Texture * texture, int x, int y) {
  m_texture = texture;
  m_x = x;
  m_y = y;
  m_destroyed = false;
}

void Brick::destroy() {
  m_destroyed = true;
}

bool Brick::isDestroyed() {
  return m_destroyed;
}

void Brick::render(SDL_Renderer * renderer) {
  SDL_Rect rect = {
    m_x,
    m_y,
    BRICK_WIDTH,
    BRICK_HEIGHT
  };
  SDL_RenderCopy(renderer, m_texture, NULL, & rect);
}

bool checkCollision(Ball ball, Paddle paddle) {
  int ballLeft = ball.getX() - BALL_RADIUS;
  int ballRight = ball.getX() + BALL_RADIUS;
  int ballTop = ball.getY() - BALL_RADIUS;
  int ballBottom = ball.getY() + BALL_RADIUS;
  int paddleLeft = paddle.getX();
  int paddleRight = paddle.getX() + PADDLE_WIDTH;
  int paddleTop = paddle.getY();
  int paddleBottom = paddle.getY() + PADDLE_HEIGHT;
  if (ballBottom >= paddleTop && ballTop <= paddleBottom && ballRight >= paddleLeft && ballLeft <= paddleRight) {
    return true;
  }
  return false;
}

bool checkCollision(Ball ball, Brick brick) {
  int ballLeft = ball.getX() - BALL_RADIUS;
  int ballRight = ball.getX() + BALL_RADIUS;
  int ballTop = ball.getY() - BALL_RADIUS;
  int ballBottom = ball.getY() + BALL_RADIUS;
  int brickLeft = brick.getX();
  int brickRight = brick.getX() + BRICK_WIDTH;
  int brickTop = brick.getY();
  int brickBottom = brick.getY() + BRICK_HEIGHT;
  if (ballBottom >= brickTop && ballTop <= brickBottom && ballRight >= brickLeft && ballLeft <= brickRight) {
    return true;
  }
  return false;
}

int main(int argc, char * argv[]) {
  // Initialize SDL
  SDL_Init(SDL_INIT_VIDEO);

  // Create a window
  SDL_Window * window = SDL_CreateWindow("Arkanoid", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, 0);

  // Create a renderer
  SDL_Renderer * renderer = SDL_CreateRenderer(window, -1, 0);

  // Load textures
  SDL_Surface * ballSurface = IMG_Load("ball.png");
  SDL_Texture * ballTexture = SDL_CreateTextureFromSurface(renderer, ballSurface);
  SDL_FreeSurface(ballSurface);

  SDL_Surface * paddleSurface = IMG_Load("paddle.png");
  SDL_Texture * paddleTexture = SDL_CreateTextureFromSurface(renderer, paddleSurface);
  SDL_FreeSurface(paddleSurface);

  SDL_Surface * brickSurface = IMG_Load("brick.png");
  SDL_Texture * brickTexture = SDL_CreateTextureFromSurface(renderer, brickSurface);
  SDL_FreeSurface(brickSurface);

  // Initialize game objects
  Ball ball(ballTexture, SCREEN_WIDTH / 2, SCREEN_HEIGHT - PADDLE_HEIGHT - BALL_RADIUS);
  Paddle paddle(paddleTexture, SCREEN_WIDTH / 2 - PADDLE_WIDTH / 2, SCREEN_HEIGHT - PADDLE_HEIGHT);
  std::vector < Brick > bricks;
  for (int i = 0; i < NUM_BRICKS; i++) {
    int x = (i % BRICKS_PER_ROW) * (BRICK_WIDTH + BRICK_GAP) + BRICK_OFFSET_X;
    int y = (i / BRICKS_PER_ROW) * (BRICK_HEIGHT + BRICK_GAP) + BRICK_OFFSET_Y;
    Brick brick(brickTexture, x, y);
    bricks.push_back(brick);
  }

  // Game loop
  bool running = true;
  while (running) {
    // Handle events
    SDL_Event event;
    while (SDL_PollEvent( & event)) {
      if (event.type == SDL_QUIT) {
        running = false;
      } else if (event.type == SDL_KEYDOWN) {
        switch (event.key.keysym.sym) {
        case SDLK_LEFT:
          paddle.moveLeft();
          break;
        case SDLK_RIGHT:
          paddle.moveRight();
          break;
        }
      }
    }

    // Update game objects
    ball.update();
    if (checkCollision(ball, paddle)) {
      ball.reverseY();
    }
    for (int i = 0; i < bricks.size(); i++) {
      if (!bricks[i].isDestroyed() && checkCollision(ball, bricks[i])) {
        bricks[i].destroy();
        ball.reverseY();
      }
    }

    // Clear screen
    SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
    SDL_RenderClear(renderer);

    // Render game objects
    ball.render(renderer);
    paddle.render(renderer);
    for (int i = 0; i < bricks.size(); i++) {
      if (!bricks[i].isDestroyed()) {
        bricks[i].render(renderer);
      }
    }

    // Update screen
    SDL_RenderPresent(renderer);

    // Delay to control frame rate
    SDL_Delay(16);
  }

  // Clean up
  SDL_DestroyTexture(ballTexture);
  SDL_DestroyTexture(paddleTexture);
  SDL_DestroyTexture(brickTexture);
  SDL_DestroyRenderer(renderer);
  SDL_DestroyWindow(window);
  SDL_Quit();

  return 0;
}

Не знаю насчет верилога, но даже предыдущая версия сносно осиливала очень специфичные вещи вроде написания VST-плагина для гитарных эффектов

Нет и не будет никакого красивого API. Просто потому, что в конечном итоге это все равно костыль, только со стороны разработчиков драйвера. Так что, это всего лишь костыль для активации другого костыля...

Вопрос от человека, отставшего от разработки под Андроид:

Все уже окончательно перешли на Котлин, или Джаву ещё вполне себе используют? Везде все пишут про библиотеки, которые или сильно завязаны на Котлин, либо же в Джаве ими пользоваться мучительно больно. В то же время, Джава используется много где, тогда я как Котлин на практике можно встретить только в Андроид-разработке, и особо ради этого учить его желания нет... Стоит ли Котлин того?

При всем уважении, квейк это ещё более однотипные средневековые замки

Information

Rating
Does not participate
Location
Киев, Киевская обл., Украина
Date of birth
Registered
Activity