YourWishes/Dawn
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactoring some of the poker game logic again.

Browse Source
This commit is contained in:
Dominic Masters
2021-07-27 09:49:54 -07:00
parent 2a4b1fa8da
commit cf4d4cd710
36 changed files with 99 additions and 304 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
src/game/game.c
View File

@ -7,20 +7,12 @@
#include "game.h"
testscene_t testScene;
bool gameInit(game_t *game) {
// Init the game
game->name = GAME_NAME;
// Init the engine and the rendering pipeline
engineInit(&game->engine, game);
// Hand off to the poker logic.
testSceneInit(&testScene, game);
// pokerInit(&game->poker, &game->engine);
return true;
// Send off to the game instance
return pokerGameInit(game);
}
bool gameUpdate(game_t *game, float platformDelta) {
@ -28,15 +20,13 @@ bool gameUpdate(game_t *game, float platformDelta) {
engineUpdateStart(&game->engine, game, platformDelta);
// Hand off to the poker logic
testSceneRender(&testScene, game);
// pokerUpdate(&game->poker, &game->engine);
pokerGameUpdate(game);
// Hand back to the engine.
return engineUpdateEnd(&game->engine, game);
}
void gameDispose(game_t *game) {
pokerDispose(&game->poker);
pokerGameDispose(game);
engineDispose(&game->engine, game);
}

3
src/game/game.h
View File

@ -6,8 +6,7 @@
#pragma once
#include <dawn/dawn.h>
#include "../engine/engine.h"
#include "../poker/poker.h"
#include "../test/testscene.h"
#include "poker/pokergame.h"
/**
* Initialize the game context.

23
src/game/poker/pokergame.c Normal file
View File

@ -0,0 +1,23 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#include "pokergame.h"
bool pokerGameInit(game_t *game) {
// Init the game
game->name = POKER_GAME_NAME;
// Hand off to the poker logic.
pokerInit(&game->pokerGame.poker, &game->engine);
}
void pokerGameUpdate(game_t *game) {
}
void pokerGameDispose(game_t *game) {
}

30
src/game/poker/pokergame.h Normal file
View File

@ -0,0 +1,30 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include <dawn/dawn.h>
#include "../../poker/poker.h"
/**
* Initializes the game state for the poker game.
*
* @param game Game to initialize.
* @returns True if successful, otherwise false.
*/
bool pokerGameInit(game_t *game);
/**
* Updates the poker game instance.
* @param game Game to update for.
*/
void pokerGameUpdate(game_t *game);
/**
* Disposes a previously initialized poker game instance.
* @param game Game to initialize for.
*/
void pokerGameDispose(game_t *game);

1
src/poker/player.c
View File

@ -15,7 +15,6 @@ bool pokerPlayerIsHuman(poker_t *poker, pokerplayer_t *player) {
return (poker->players + POKER_PLAYER_HUMAN_INDEX) == player;
}
void pokerPlayerReset(pokerplayer_t *player) {
player->cardCount = 0;
player->currentBet = 0;

30
src/poker/poker.c
View File

@ -7,21 +7,8 @@
#include "poker.h"
void pokerInit(poker_t *poker, engine_t *engine) {
// Load the main shader
assetShaderLoad(&poker->shader,
"shaders/textured.vert", "shaders/textured.frag"
);
void pokerInit(poker_t *poker) {
// Initialize the render stuffs.
pokerFrameInit(poker, &engine->render);
pokerWorldInit(poker);
pokerCardInit(poker);
pokerPlayerInit(poker);
// pokerTalkInit(poker);
// Hand over to the deal for the first time.
pokerMatchInit(poker, engine);
}
void pokerUpdate(poker_t *poker, engine_t *engine) {
@ -39,22 +26,7 @@ void pokerUpdate(poker_t *poker, engine_t *engine) {
default:
break;
}
shaderUse(&poker->shader);
pokerFrameWorld(poker, &engine->render);
pokerWorldRender(poker);
for(uint8_t pi = 0; pi < POKER_PLAYER_COUNT; pi++) {
uint8_t seat = pokerPlayerGetSeatForPlayer(pi);
pokerPlayerRender(poker, poker->players + pi, seat);
}
pokerFrameGui(poker, &engine->render);
// pokerTalkRender(poker, &engine->input);
}
void pokerDispose(poker_t * poker) {
// pokerTalkDispose(poker);
pokerWorldDispose(poker);
shaderDispose(&poker->shader);
}

14
src/poker/poker.h
View File

@ -7,25 +7,13 @@
#pragma once
#include <dawn/dawn.h>
#include "round/match.h"
#include "render/frame.h"
#include "render/world.h"
#include "render/card.h"
#include "render/player.h"
#include "render/look.h"
#include "../file/asset.h"
#include "../display/shader.h"
#include "../display/camera.h"
#include "../display/gui/font.h"
/**
* Initializes the poker context for the first time.
* @param poker Poker context to initialize.
* @param engine Rendering context.
*/
void pokerInit(poker_t *poker, engine_t *engine);
void pokerInit(poker_t *poker);
/**
* Updates the poker context.

99
src/poker/render/card.c
View File

@ -1,99 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "card.h"
void pokerCardInit(poker_t *poker) {
tilesetdiv_t *cardBack;
// Load Cards Texture
assetTextureLoad(&poker->cardTexture, "cards_normal.png");
tilesetInit(&poker->cardTileset,
CARD_COUNT_PER_SUIT, 6,
poker->cardTexture.width, poker->cardTexture.height,
0, 0,
0, 0
);
// Cards Primitive
cardBack = poker->cardTileset.divisions+(poker->cardTileset.columns * 4);
primitiveInit(&poker->cardPrimitive,
QUAD_VERTICE_COUNT * 2, QUAD_INDICE_COUNT * 2
);
quadBuffer(&poker->cardPrimitive, -POKER_CARD_DEPTH,
-POKER_CARD_WIDTH, -POKER_CARD_HEIGHT,
cardBack->x0, cardBack->y1,
POKER_CARD_WIDTH, POKER_CARD_HEIGHT,
cardBack->x1, cardBack->y0,
QUAD_VERTICE_COUNT, QUAD_INDICE_COUNT
);
}
pokerposition_t pokerCardGetPosition(uint8_t seat, uint8_t slot) {
pokerposition_t position;
float t, t2;
position.yaw = POKER_SEAT_ANGLE(seat);
position.x = sin(position.yaw) * -0.75;
position.z = cos(position.yaw) * -0.75;
t = position.yaw + mathDeg2Rad(90);
switch (slot) {
case POKER_CARD_SLOT_HAND0:
case POKER_CARD_SLOT_HAND1:
t2 = POKER_CARD_WIDTH+POKER_CARD_PADDING;
if(slot == POKER_CARD_SLOT_HAND0) t2 = -t2;
t2 += 0.1;
break;
case POKER_CARD_SLOT_FLOP0:
case POKER_CARD_SLOT_FLOP1:
case POKER_CARD_SLOT_FLOP2:
case POKER_CARD_SLOT_FLOP3:
case POKER_CARD_SLOT_FLOP4:
t2 = POKER_CARD_WIDTH*2+POKER_CARD_PADDING;
t2 = (
-t2 * ( POKER_CARD_SLOT_FLOP4-POKER_CARD_SLOT_FLOP0)
)/2 + t2*(slot-POKER_CARD_SLOT_FLOP0);
break;
default:
break;
}
position.x += t2 * sin(t);
position.z += t2 * cos(t);
return position;
}
void pokerCardRender(poker_t *poker, card_t card, float x, float y, float z,
float pitch, float yaw, float roll
) {
tilesetdiv_t *cardFront = poker->cardTileset.divisions + card;
quadBuffer(&poker->cardPrimitive, POKER_CARD_DEPTH,
-POKER_CARD_WIDTH, -POKER_CARD_HEIGHT,
cardFront->x0, cardFront->y1,
POKER_CARD_WIDTH, POKER_CARD_HEIGHT,
cardFront->x1, cardFront->y0,
0, 0
);
shaderUseTexture(&poker->shader, &poker->cardTexture);
shaderUsePosition(&poker->shader, x,y,z, pitch,yaw,roll);
primitiveDraw(&poker->cardPrimitive, 0, -1);
}
void pokerCardRenderForSeat(poker_t *poker, uint8_t seat, card_t card, uint8_t slot) {
pokerposition_t position = pokerCardGetPosition(seat, slot);
pokerCardRender(poker, card,
position.x, 0, position.z,
mathDeg2Rad(-90), position.yaw, 0
);
}

55
src/poker/render/card.h
View File

@ -1,55 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include <dawn/dawn.h>
#include "../../file/asset.h"
#include "../../display/shader.h"
#include "../../display/primitive.h"
#include "../../display/primitives/quad.h"
#include "../../display/tileset.h"
/**
* Initializes the Card Renderer.
* @param poker The poker game context.
*/
void pokerCardInit(poker_t *poker);
/**
* Returns the position a card "naturally" sits at for a given seat and slot.
*
* @param seat Seat that the card belongs to
* @param slot Slot within the player/dealers' hand that the card belongs to.
* @return A struct containing X, Z and YAW properties.
*/
pokerposition_t pokerCardGetPosition(uint8_t seat, uint8_t slot);
/**
* Render's a given card at the specified coordinates. Card is a reused quad
* and is re-buffered to for every draw call.
*
* @param poker The poker game context.
* @param card Card to render.
* @param x X Position (world space).
* @param y Y Position (world space).
* @param z Z Position (world space).
* @param pitch Pitch angle.
* @param yaw Yaw angle.
* @param roll Roll angle.
*/
void pokerCardRender(poker_t *poker, card_t card, float x, float y, float z,
float pitch, float yaw, float roll
);
/**
* Render's a card at a given seat and slot.
* @param poker The poker game context.
* @param seat Seat the card is for.
* @param card Card to render.
* @param slot Slot the card is for.
*/
void pokerCardRenderForSeat(poker_t *poker, uint8_t seat, card_t card, uint8_t slot);

45
src/poker/render/frame.c
View File

@ -1,45 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#include "frame.h"
void pokerFrameInit(poker_t *poker, render_t *render) {
frameBufferInit(&poker->frameWorld, render->width, render->height);
frameBufferInit(&poker->frameGui, render->width, render->height);
}
void pokerFrameWorld(poker_t *poker, render_t *render) {
// Update the frame buffer
frameBufferResize(&poker->frameWorld, render->width, render->height);
// Correct the aspect on the perspective camera for the world
cameraPerspective(&poker->cameraWorld, 20,
render->width / render->height,
0.001, 1000
);
shaderUseCamera(&poker->shader, &poker->cameraWorld);
}
void pokerFrameGui(poker_t *poker, render_t *render) {
// Update FB
frameBufferResize(&poker->frameGui, render->width, render->height);
poker->guiWidth = ((float)POKER_GUI_HEIGHT/render->height) * render->width;
// frameBufferUse(&poker->frameGui, true);
// Correct aspect on the ortho camera
cameraOrtho(&poker->cameraGui,
0, poker->guiWidth,
POKER_GUI_HEIGHT, 0,
0.01, 100
);
cameraLookAt(&poker->cameraGui, 0, 0, 5, 0, 0, 0);
shaderUseCamera(&poker->shader, &poker->cameraGui);
}
void pokerFrameRender(poker_t *poker, render_t *render) {
}

43
src/poker/render/frame.h
View File

@ -1,43 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include <dawn/dawn.h>
#include "../../display/framebuffer.h"
#include "../../display/primitive.h"
#include "../../display/texture.h"
#include "../../display/shader.h"
#include "../../display/camera.h"
#include "../../display/primitives/quad.h"
#include "../../display/gui/font.h"
/**
* Initializes the various frame buffers for the poker game.
*
* @param poker Poker game to initialize for
* @param render Rendering context.
*/
void pokerFrameInit(poker_t *poker, render_t *render);
/**
* Bind the world frame, this will also correct the camera angles.
*
* @param poker Poker game context.
* @param render Rendering engine context.
*/
void pokerFrameWorld(poker_t *poker, render_t *render);
/**
* Bind the frame for GUI rendering.
*
* @param poker Poker game context.
* @param render Rendering engine context.
*/
void pokerFrameGui(poker_t *poker, render_t *render);
void pokerFrameTest(poker_t *poker, render_t *render);

30
src/poker/render/look.c
View File

@ -1,30 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#include "look.h"
void pokerLookAtPlayer(camera_t *camera, uint8_t seat, float distance) {
float x, z, angle;
angle = POKER_SEAT_ANGLE(seat);
x = sin(angle) * (0.8 + distance);
z = cos(angle) * (0.8 + distance);
cameraLookAt(camera,
x, 0.3, z,
-x, 0.3, -z
);
}
void pokerLookAtHand(camera_t *camera, uint8_t seat) {
float x, z, angle;
angle = POKER_SEAT_ANGLE(seat);
x = sin(angle);
z = cos(angle);
cameraLookAt(camera,
x*0.1, 0.8, z*0.1,
-x*0.5, 0.2, -z*0.5
);
}

26
src/poker/render/look.h
View File

@ -1,26 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#include <dawn/dawn.h>
#include "../../display/camera.h"
/**
* Look at a specific seats' player.
*
* @param camera Camera to adjust.
* @param seat Seat to look at.
* @param distance Distance from the seat to look from. 0 is default.
*/
void pokerLookAtPlayer(camera_t *camera, uint8_t seat, float distance);
/**
* Look at a specific seats' hand.
*
* @param camera Camera to adjust.
* @param seat Seats hand to look at.
*/
void pokerLookAtHand(camera_t *camera, uint8_t seat);

68
src/poker/render/player.c
View File

@ -1,68 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#include "player.h"
void pokerPlayerInit(poker_t *poker) {
uint8_t i;
pokerplayer_t *player;
float w, h;
for(i = 0; i < POKER_PLAYER_COUNT; i++) {
player = poker->players + i;
assetTextureLoad(&player->bodyTexture, "characters/penny/textures/body.png");
assetTextureLoad(&player->faceTexture, "characters/penny/textures/face.png");
w = 0.6;
h=((float)player->faceTexture.width)/((float)player->faceTexture.height)*w;
w = w / 2;
h = h / 2;
quadInit(&player->bodyPrimitive, 0,
-w, -h, 0, 1,
w, h, 1, 0
);
quadInit(&player->facePrimitive, 0,
-w, -h, 0, 1,
w, h, 1, 0
);
}
}
uint8_t pokerPlayerGetSeatForPlayer(uint8_t player) {
switch(player) {
case 0x01:
return POKER_SEAT_PLAYER1;
case 0x02:
return POKER_SEAT_PLAYER2;
case 0x03:
return POKER_SEAT_PLAYER3;
case 0x04:
return POKER_SEAT_PLAYER4;
default:
return POKER_SEAT_PLAYER0;
}
}
void pokerPlayerRender(poker_t* poker, pokerplayer_t *player, uint8_t seat) {
float x, z, angle;
float w, h;
// Determine position
angle = POKER_SEAT_ANGLE(seat);
x = sin(angle) * -1;
z = cos(angle) * -1;
shaderUsePosition(&poker->shader, x,0.34,z, 0,angle,0);
// Render Body
shaderUseTexture(&poker->shader, &player->bodyTexture);
primitiveDraw(&player->bodyPrimitive, 0, -1);
// Render Face
shaderUseTexture(&poker->shader, &player->faceTexture);
primitiveDraw(&player->facePrimitive, 0, -1);
}

34
src/poker/render/player.h
View File

@ -1,34 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include <dawn/dawn.h>
#include "../../file/asset.h"
#include "../../display/shader.h"
#include "../../display/primitive.h"
#include "../../display/tileset.h"
#include "../../display/primitives/quad.h"
/**
* Initializes the player renderer.
* @param poker Poker game context.
*/
void pokerPlayerInit(poker_t *poker);
/**
* Returns the seat index for a given player.
* @param player Player to get the seat for.
* @return Seat ID for the given player.
*/
uint8_t pokerPlayerGetSeatForPlayer(uint8_t player);
/**
* Render's a player at a seat.
* @param poker Poker game context.
* @param seat Seat to render the player at.
*/
void pokerPlayerRender(poker_t *poker, pokerplayer_t *player, uint8_t seat);

30
src/poker/render/world.c
View File

@ -1,30 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#include "world.h"
void pokerWorldInit(poker_t *poker) {
// Poker Table
pokerTableInit(&poker->tablePrimitive);
assetTextureLoad(&poker->tableTexture, "pokertable.png");
}
void pokerWorldRender(poker_t *poker) {
// Poker Table
shaderUsePositionAndScale(&poker->shader,
0, -0.01, 0,
0, 0, 0,
3.4, 3.4, 3.4
);
shaderUseTexture(&poker->shader, &poker->tableTexture);
primitiveDraw(&poker->tablePrimitive, 0, -1);
}
void pokerWorldDispose(poker_t *poker) {
textureDispose(&poker->tableTexture);
primitiveDispose(&poker->tablePrimitive);
}

32
src/poker/render/world.h
View File

@ -1,32 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include <dawn/dawn.h>
#include "../../assets/models/pokertable.h"
#include "../../display/shader.h"
#include "../../display/primitive.h"
#include "../../display/texture.h"
#include "../../file/asset.h"
/**
* Initializes the world renderer.
* @param poker Poker scene to initialize.
*/
void pokerWorldInit(poker_t *poker);
/**
* Renders the world.
* @param poker Poker scene to render.
*/
void pokerWorldRender(poker_t *poker);
/**
* Disposes a poker world.
* @param poker Poker game to cleanup the world for.
*/
void pokerWorldDispose(poker_t *poker);

15
src/poker/round/bet.c
View File

@ -9,10 +9,10 @@
void pokerRoundBetPlayerNext(poker_t *poker) {
// Go to next player, keep contained.
poker->roundBetCurrent = (poker->roundBetCurrent + 1) % POKER_PLAYER_COUNT;
poker->bet.better = (poker->bet.better + 1) % POKER_PLAYER_COUNT;
// Did we go full circle?
if(poker->roundBetCurrent == poker->roundSmallBlind) {
if(poker->bet.better == poker->roundSmallBlind) {
if(poker->round == POKER_ROUND_BET3) {
pokerWinnerInit(poker);
return;
@ -23,7 +23,7 @@ void pokerRoundBetPlayerNext(poker_t *poker) {
}
// Init the next player
pokerRoundBetPlayerInit(poker, poker->players + poker->roundBetCurrent);
pokerRoundBetPlayerInit(poker, poker->players + poker->bet.better);
}
@ -34,7 +34,7 @@ void pokerRoundBetPlayerInit(poker_t *poker, pokerplayer_t *player) {
return;
}
printf("Betting round player %u\n", poker->roundBetCurrent);
printf("Betting round player %u\n", poker->bet.better);
if(pokerPlayerIsHuman(poker, player)) {
pokerRoundBetPlayerNext(poker);
return;
@ -47,7 +47,6 @@ void pokerRoundBetPlayerUpdate(poker_t *poker, pokerplayer_t *player) {
}
void pokerRoundBetInit(poker_t *poker) {
printf("Betting round start\n");
@ -66,11 +65,11 @@ void pokerRoundBetInit(poker_t *poker) {
}
// Set the inital player
poker->roundBetCurrent = poker->roundSmallBlind;
pokerRoundBetPlayerInit(poker, poker->players+poker->roundBetCurrent);
poker->bet.better = poker->roundSmallBlind;
pokerRoundBetPlayerInit(poker, poker->players + poker->bet.better);
}
void pokerRoundBetUpdate(poker_t *poker) {
// Take the current player
pokerRoundBetPlayerUpdate(poker, poker->players + poker->roundBetCurrent);
pokerRoundBetPlayerUpdate(poker, poker->players + poker->bet.better);
}

3
src/poker/round/deal.c
View File

@ -9,9 +9,6 @@
void pokerDealInit(poker_t *poker) {
poker->round = POKER_ROUND_DEAL;
// Hard look at the dealer
pokerLookAtPlayer(&poker->cameraWorld, POKER_SEAT_DEALER, 0);
// Shuffle the deck
cardShuffle(poker->dealer.deck, CARD_DECK_SIZE);

1
src/poker/round/deal.h
View File

@ -8,7 +8,6 @@
#pragma once
#include <dawn/dawn.h>
#include "../../util/array.h"
#include "../render/look.h"
#include "../dealer.h"
#include "../card.h"
#include "bet.h"

11
src/poker/round/match.c
View File

@ -9,13 +9,9 @@
void pokerMatchInit(poker_t *poker, engine_t *engine) {
uint8_t x;
// Look at the dealer
poker->roundMatch.time = engine->time.current;
// Reset the main game state. This does not init the round.
pokerBetInit(&poker->bet);
poker->roundDealer = POKER_PLAYER_COUNT-2;
poker->roundTextCounter = 0;
poker->round = POKER_ROUND_MATCH;
for(x = 0; x < POKER_PLAYER_COUNT; x++) {
@ -23,13 +19,8 @@ void pokerMatchInit(poker_t *poker, engine_t *engine) {
poker->players[x].chips = POKER_BET_PLAYER_CHIPS_DEFAULT;
}
printf("Match Start\n");
// pokerStartInit(poker);
pokerStartInit(poker);
}
void pokerMatchUpdate(poker_t *poker, engine_t *engine) {
// Ease into the game.
float t = easeTimeToEase(poker->roundMatch.time, engine->time.current, 5);
pokerLookAtPlayer(&poker->cameraWorld, POKER_SEAT_PLAYER0, (
t < 1 ? 1 - easeOutQuart(t) : 0
));
}

1
src/poker/round/match.h
View File

@ -8,7 +8,6 @@
#pragma once
#include <dawn/dawn.h>
#include "start.h"
#include "../render/look.h"
/**
* Init the poker match round.

4
src/test/testscene.c
View File

@ -45,8 +45,8 @@ void testSceneInit(testscene_t *scene, game_t *game) {
// Add some conversation peices.
vnConversationTalk(&scene->conversation, "Hello World", &scene->character1);
queueDelay(&scene->conversation.actionQueue, 3);
vnConversationTalk(&scene->conversation, "What?", &scene->character1);
queueDelay(&scene->conversation.actionQueue, 1);
vnConversationTalk(&scene->conversation, "What?", &scene->character2);
queueNext(&scene->conversation.actionQueue);
}

7
src/vn/conversation/talk.c
View File

@ -10,13 +10,18 @@
void _vnConversationTalkStart(queue_t *queue,queueaction_t *action,uint8_t i) {
vnconversationitemdata_t *data;
data = (vnconversationitemdata_t *)action->data;
vnTextBoxSetText(&data->conversation->textbox, data->text);
if(data->character != NULL) data->character->talking = true;
if(data->character != NULL) {
data->character->talking = true;
}
}
void _vnConversationTalkUpdate(queue_t *queue,queueaction_t *action,uint8_t i) {
vnconversationitemdata_t *data;
data = (vnconversationitemdata_t *)action->data;
if(data->conversation->textbox.state & VN_TEXTBOX_STATE_CLOSED) {
if(data->character != NULL) data->character->talking = false;
queueNext(queue);