BitmapTextComponentManager::BitmapTextComponentManager(
LoaderManager* loaderManager,
RenderPass* renderPass,
SpriteRenderer* spriteRenderer,
size_t componentBlockSize)
: DenseComponentManager("text", componentBlockSize),
_loader(loaderManager),
_renderPass(renderPass),
_spriteRenderer(spriteRenderer),
_states() {
lairAssert(_loader);
lairAssert(_renderPass);
lairAssert(_spriteRenderer);
}
void Window::setVisible(bool visible) {
lairAssert(isValid());
if(visible)
SDL_ShowWindow(_window);
else
SDL_HideWindow(_window);
}
void MainState::nextMessage() {
lairAssert(!_messages.empty());
_messages.pop_front();
if(!_messages.empty()) {
layoutMessage();
}
}
void _LoaderThread::start() {
lairAssert(!_running && _manager);
if(_thread.joinable()) {
wait();
}
_manager->log().debug("Starting loader thread...");
_running = true;
_thread = std::thread(&_LoaderThread::_run, this);
}
void Menu::enableEntry(unsigned i) {
lairAssert(i < _entries.size());
if(_entries[i].status != ENABLED) {
++_nSelectable;
if(_nSelectable == 1) {
_selected = i;
}
}
_entries[i].status = ENABLED;
}
void Menu::disableEntry(unsigned i) {
lairAssert(i < _entries.size());
if(_entries[i].status == ENABLED) {
--_nSelectable;
if(_selected == i) {
selectNext();
}
}
_entries[i].status = DISABLED;
}
void _LoaderThread::wait() {
lairAssert(_thread.joinable());
if(_running) {
stop();
}
auto id = _thread.get_id();
_manager->log().debug("Joinning loader thread ", id, "...");
_thread.join();
_manager->log().debug("Joined loader thread ", id, ".");
}
void Window::setFullscreen(bool fullscreen) {
lairAssert(isValid());
unsigned flag = 0;
if(fullscreen) {
flag = SDL_WINDOW_FULLSCREEN_DESKTOP;
}
int r = SDL_SetWindowFullscreen(_window, flag);
if(r != 0) {
// TODO
}
}
Menu::Menu(Sprite* bg, Font* font, MenuInputs* inputs,
const Callback& cancelCallback, const Vector2& size)
: anchor(0, 0),
margin(12, 12),
indent(12),
textColor(1, 1, 1, 1),
disabledColor(.5, .5, .5, 1),
_inputs(inputs),
_cancelCallback(cancelCallback),
_selected(0),
_nSelectable(0),
_entries(),
_visible(false),
_frame(bg, size),
_font(font) {
lairAssert(bg);
}
void Loader::loadSync(Logger& log) {
lairAssert(!_isLoaded);
// It is *very* important to catch exceptions here, or waiting threads
// could wait forever. Moreover, it would unexpectedly stop a worker
// thread.
try {
loadSyncImpl(log);
} catch(std::exception e) {
log.error("Exception caught while loading \"", asset()->logicPath(), "\": ", e.what());
}
{
std::unique_lock<std::mutex> lk(_mutex);
_isLoaded = true;
}
_cv.notify_all();
}
void Window::destroy() {
lairAssert(isValid());
log().log("Destroy window: \"", utf8Title(), "\"");
// onDestroy();
unsigned id = _windowID();
SDL_GL_DeleteContext(_glContext);
_glContext = 0;
SDL_DestroyWindow(_window);
_window = 0;
if(_sys) {
// DELETE THE WINDOW ! Do not do anything after this.
_sys->_removeWindow(id);
}
}
void SplashState::run() {
lairAssert(_initialized);
log().log("Starting splash state...");
_running = true;
_loop.start();
_fpsTime = sys()->getTimeNs();
_fpsCount = 0;
do {
switch(_loop.nextEvent()) {
case InterpLoop::Tick:
updateTick();
break;
case InterpLoop::Frame:
updateFrame();
break;
}
} while (_running);
_loop.stop();
}
void MainState::run() {
lairAssert(_initialized);
log().log("Starting main state...");
_running = true;
_loop.start();
_fpsTime = _game->sys()->getTimeNs();
_fpsCount = 0;
unsigned lvl = 0;
do {
log().log("Our heroes strike",(lvl?".":" again !"));
lvl += 20;
_player.strat[rand()%NB_STRATS] = true;
_player.strat[rand()%NB_STRATS] = true;
_player.strat[rand()%NB_STRATS] = true;
initFight(lvl);
_state = PLAYING;
do {
switch(_loop.nextEvent()) {
case InterpLoop::Tick:
updateTick();
break;
case InterpLoop::Frame:
updateFrame();
break;
}
} while (_state != GAME_OVER && _running);
} while (_fight->boss.hp && _running);
log().log("The mighty has fallen...");
log().log("Stopping main state...");
_loop.stop();
}
void _LoaderThread::setManager(LoaderManager* manager) {
lairAssert(manager);
_manager = manager;
_logger.setFrom(_manager->log());
}
Box2 CollisionComponent::worldAlignedBox() const {
lairAssert(_shape && _shape->type() == SHAPE_ALIGNED_BOX);
Vector2 pos = EntityRef(_entityPtr).computeWorldTransform().translation().head<2>();
return Box2(pos + _shape->point(0), pos + _shape->point(1));
}
const char* Window::utf8Title() const {
lairAssert(isValid());
return SDL_GetWindowTitle(_window);
}
bool Window::isVisible() const {
lairAssert(isValid());
return SDL_GetWindowFlags(_window) & SDL_WINDOW_SHOWN;
}
void Window::resize(int width, int height) {
lairAssert(isValid());
SDL_SetWindowSize(_window, width, height);
}
void MainState::doAction() {
lairAssert(!_menuStack.empty());
int target = 3 - _menuStack.back()->selected();
switch(_menuStack[0]->selected()) {
case MAIN_ATTACK: {
lairAssert(_menuStack.size() == 2);
_fight->curse(PUNCH, target);
break;
}
case MAIN_SWITCH: {
lairAssert(_menuStack.size() == 2);
switch(_menuStack[1]->selected()) {
case NONE:
_fight->curse(SWITCH, NONE);
break;
case FIRE:
_fight->curse(SWITCH, FIRE);
break;
case ICE:
_fight->curse(SWITCH, ICE);
break;
case SPARK:
_fight->curse(SWITCH, SPARK);
break;
case ACID:
_fight->curse(SWITCH, ACID);
break;
}
break;
}
case MAIN_SPELL: {
lairAssert(_menuStack.size() >= 2);
switch(_menuStack[1]->selected()) {
case SPELL_STORM:
lairAssert(_menuStack.size() == 2);
_fight->curse(STORM, -1);
break;
case SPELL_STRIKE:
lairAssert(_menuStack.size() == 3);
_fight->curse(STRIKE, target);
break;
case SPELL_CRIPPLE:
lairAssert(_menuStack.size() == 3);
_fight->curse(CRIPPLE, target);
break;
case SPELL_DRAIN:
lairAssert(_menuStack.size() == 3);
_fight->curse(DRAIN, target);
break;
case SPELL_VORPAL:
lairAssert(_menuStack.size() == 3);
_fight->curse(VORPAL, target);
break;
case SPELL_MUD:
lairAssert(_menuStack.size() == 2);
_fight->curse(MUD, -1);
break;
case SPELL_DISPEL:
lairAssert(_menuStack.size() == 3);
_fight->curse(DISPEL, target);
break;
}
break;
}
case 3: { // summon
break;
}
}
updateHealthBars();
_state = PLAYING;
while(!_menuStack.empty()) {
closeMenu();
}
}
int Window::width() const {
lairAssert(isValid());
int w;
SDL_GetWindowSize(_window, &w, 0);
return w;
}
Window::Window(SysModule* sys)
: _sys(sys),
_window(nullptr),
_glContext(nullptr) {
lairAssert(sys);
}
Logger& Window::log() {
lairAssert(_sys);
return _sys->log();
}
void Window::setUtf8Title(const char* utf8Title) {
lairAssert(isValid());
SDL_SetWindowTitle(_window, utf8Title);
}
uint8 Menu::entryStatus(unsigned i) const {
lairAssert(i < _entries.size());
return _entries[i].status;
}
TileLayerComponent* TileLayerComponentManager::addComponentFromJson(EntityRef /*entity*/, const Json::Value& /*json*/,
const Path& /*cd*/) {
lairAssert(false);
return nullptr;
}
void Menu::setSelected(unsigned index) {
lairAssert(index < _entries.size());
_selected = index;
}
void _LoaderThread::stop() {
lairAssert(_running && _thread.joinable());
_manager->log().debug("Stopping loader thread ", _thread.get_id(), "...");
_running = false;
}
int Window::height() const {
lairAssert(isValid());
int h;
SDL_GetWindowSize(_window, 0, &h);
return h;
}
SDL_Window* Window::_create(const char* utf8Title, int width, int height) {
lairAssert(!isValid());
// SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
// SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
// SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
unsigned windowFlags = 0
| SDL_WINDOW_OPENGL
// | SDL_WINDOW_FULLSCREEN_DESKTOP
;
_window = SDL_CreateWindow(
utf8Title,
SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
width, height,
windowFlags);
if(!_window) {
log().error("Failed to create SDL window.", SDL_GetError());
return 0;
}
_glContext = SDL_GL_CreateContext(_window);
if(!_glContext) {
log().error("failed to create OpenGL context: ", SDL_GetError());
SDL_DestroyWindow(_window);
return 0;
}
typedef std::pair<const char*, SDL_GLattr> GLAttr;
GLAttr glAttrs[] =
{
std::make_pair("SDL_GL_RED_SIZE = ", SDL_GL_RED_SIZE),
std::make_pair("SDL_GL_GREEN_SIZE = ", SDL_GL_GREEN_SIZE),
std::make_pair("SDL_GL_BLUE_SIZE = ", SDL_GL_BLUE_SIZE),
std::make_pair("SDL_GL_ALPHA_SIZE = ", SDL_GL_ALPHA_SIZE),
std::make_pair("SDL_GL_BUFFER_SIZE = ", SDL_GL_BUFFER_SIZE),
std::make_pair("SDL_GL_DOUBLEBUFFER = ", SDL_GL_DOUBLEBUFFER),
std::make_pair("SDL_GL_DEPTH_SIZE = ", SDL_GL_DEPTH_SIZE),
std::make_pair("SDL_GL_STENCIL_SIZE = ", SDL_GL_STENCIL_SIZE),
std::make_pair("SDL_GL_ACCUM_RED_SIZE = ", SDL_GL_ACCUM_RED_SIZE),
std::make_pair("SDL_GL_ACCUM_GREEN_SIZE = ", SDL_GL_ACCUM_GREEN_SIZE),
std::make_pair("SDL_GL_ACCUM_BLUE_SIZE = ", SDL_GL_ACCUM_BLUE_SIZE),
std::make_pair("SDL_GL_ACCUM_ALPHA_SIZE = ", SDL_GL_ACCUM_ALPHA_SIZE),
std::make_pair("SDL_GL_STEREO = ", SDL_GL_STEREO),
std::make_pair("SDL_GL_MULTISAMPLEBUFFERS = ", SDL_GL_MULTISAMPLEBUFFERS),
std::make_pair("SDL_GL_MULTISAMPLESAMPLES = ", SDL_GL_MULTISAMPLESAMPLES),
std::make_pair("SDL_GL_ACCELERATED_VISUAL = ", SDL_GL_ACCELERATED_VISUAL),
// std::make_pair("SDL_GL_RETAINED_BACKING = ", SDL_GL_RETAINED_BACKING),
std::make_pair("SDL_GL_CONTEXT_MAJOR_VERSION = ", SDL_GL_CONTEXT_MAJOR_VERSION),
std::make_pair("SDL_GL_CONTEXT_MINOR_VERSION = ", SDL_GL_CONTEXT_MINOR_VERSION),
// std::make_pair("SDL_GL_CONTEXT_EGL = ", SDL_GL_CONTEXT_EGL),
std::make_pair("SDL_GL_CONTEXT_FLAGS = ", SDL_GL_CONTEXT_FLAGS),
std::make_pair("SDL_GL_CONTEXT_PROFILE_MASK = ", SDL_GL_CONTEXT_PROFILE_MASK),
std::make_pair("SDL_GL_SHARE_WITH_CURRENT_CONTEXT = ", SDL_GL_SHARE_WITH_CURRENT_CONTEXT),
// std::make_pair("SDL_GL_FRAMEBUFFER_SRGB_CAPABLE = ", SDL_GL_FRAMEBUFFER_SRGB_CAPABLE),
};
for(unsigned i = 0; i < (sizeof(glAttrs) / sizeof(GLAttr)); ++i) {
int attr;
SDL_GL_GetAttribute(glAttrs[i].second, &attr);
log().info(glAttrs[i].first, attr);
}
return _window;
}
bool Window::isFullscreen() const {
lairAssert(isValid());
return SDL_GetWindowFlags(_window) & SDL_WINDOW_FULLSCREEN_DESKTOP;
}
