Coordenada SpriteUnidad::getPosPies(){
switch (estadoSprite){
case CAMINANDO : return Coordenada( posicion.x + (posicion.w / 2), posicion.y + posicion.h );
case ATACANDO : return Coordenada( posicion.x + (posicion.w / 2), posicion.y + posicion.h * 0.75 );
case QUIETO : return Coordenada(posicion.x + (posicion.w / 3), posicion.y + posicion.h);
default : return Coordenada( posicion.x + (posicion.w / 2), posicion.y + posicion.h );
}
}
int main(){
Octoedro o(Coordenada(1,1,1), Coordenada(3,3,3));
std::cout << "Volumen: " << o.obtieneVolumen() << std::endl;
std::cout << "Area: " << o.obtieneArea() << std::endl;
std::vector<Coordenada> verts = o.obtieneVertices();
std::cout << "Las coordenadas son: " << std::endl;
for(int i = 0; i < verts.size(); i++){
std::cout << "\t(" << verts[i].X() << ", "<< verts[i].Y() << ", "<< verts[i].Z() << ")"<< std::endl;
}
return 0;
}
void move(Coordenada passo) {
double xFactor = largura * passo.getX() / 100.0;
double yFactor = altura * passo.getY() / 100.0;
_centro += Coordenada(xFactor, yFactor);
}
Coordenada Calculador::calcularPosicionInversa(Coordenada coord_pixel, Coordenada coord_ceros_pixel, Escenario *escenario){
int tiles_x = escenario->getDimension().first;
int tiles_y = escenario->getDimension().second;
int tileX, tileY;
bool salir = false;
int x_relativo;
int y_relativo;
int cero_relativo_x = coord_ceros_pixel.x;
int cero_relativo_y = coord_ceros_pixel.y;
for (int i = 0; i < tiles_x && !salir; i++){
x_relativo = cero_relativo_x;
y_relativo = cero_relativo_y;
for(int j = 0; j < tiles_y && !salir; j++){
if (((coord_pixel.x > x_relativo) && (coord_pixel.x < x_relativo + ANCHO_PIXEL_PASTO)) && ((coord_pixel.y > y_relativo) && (coord_pixel.y < y_relativo + ALTO_PIXEL_PASTO))){
tileX = i;
tileY = j;
salir = true;
}
x_relativo += DISTANCIA_ENTRE_X;
y_relativo += DISTANCIA_ENTRE_Y;
}
cero_relativo_x -= DISTANCIA_ENTRE_X;
cero_relativo_y += DISTANCIA_ENTRE_Y;
}
return Coordenada(tileX,tileY);
}
// Atrapar FueraDeEscenario.
Coordenada Calculador::pixelCentralDeTile(Coordenada coord_tile, Coordenada coord_ceros) {
if (coord_tile.x < 0 || coord_tile.y < 0)// || tile_x >= this->tiles_x || tile_y >= this->tiles_y)
throw FueraDeEscenario();
int pix_x = coord_ceros.x + (coord_tile.x - coord_tile.y) * DISTANCIA_ENTRE_X;
int pix_y = coord_ceros.y + (1 + coord_tile.x + coord_tile.y) * DISTANCIA_ENTRE_Y;
return Coordenada(pix_x, pix_y);
}
Coordenada Escenario::generarCoordenadaRandom(int size_x_final, int size_x_inicial, int size_y_final, int size_y_inicial, int seed = 0) {
int x_rand, y_rand;
srand(((int)time(0)) * SDL_GetTicks());
x_rand = (rand() % (size_x_final - size_x_inicial)) + size_x_inicial;
y_rand = (rand() % (size_y_final - size_y_inicial)) + size_y_inicial;
return Coordenada(x_rand,y_rand);
}
// No lanza FueraDeEscenario.
Coordenada Calculador::tileParaCualquierPixel(Coordenada coord_pixel, Coordenada coord_ceros) {
int px = coord_pixel.x - coord_ceros.x;
int py = (coord_pixel.y - coord_ceros.y) * (ANCHO_PIXEL_PASTO / ALTO_PIXEL_PASTO);
int tile_x = floor( 1.0*(px+py) / ANCHO_PIXEL_PASTO );
int tile_y = floor( 1.0*(py-px) / ANCHO_PIXEL_PASTO );
return Coordenada(tile_x,tile_y);
}
Coordenada Calculador::generarPosRandom(int size_x_final, int size_x_inicial, int size_y_final, int size_y_inicial){
random_device rd_gen;
mt19937 gen(rd_gen()); // hardcodeo de tamaño
uniform_int_distribution<int> distribucionX(size_x_inicial, size_x_final-1), distribucionY(size_y_inicial, size_y_final-1);
int x_rand = (distribucionX(gen));// % (size_x_final - size_x_inicial)) + size_x_inicial;
int y_rand = (distribucionY(gen));// % (size_y_final - size_y_inicial)) + size_y_inicial;
return Coordenada(x_rand,y_rand);
}
// Calculado con el píxel (0;0) en la esquina superior del tile (0;0). Atrapar FueraDeEscenario.
Coordenada Calculador::tileParaPixel(Coordenada coord_pixel, Coordenada coord_ceros) {
int px = coord_pixel.x - coord_ceros.x;
int py = (coord_pixel.y - coord_ceros.y) * (ANCHO_PIXEL_PASTO / ALTO_PIXEL_PASTO);
int tile_x = floor( 1.0*(px+py) / ANCHO_PIXEL_PASTO );
int tile_y = floor( 1.0*(py-px) / ANCHO_PIXEL_PASTO );
if (tile_x < 0 || tile_y < 0)//|| tile_x >= this->tiles_x || tile_y >= this->tiles_y)
throw FueraDeEscenario();
return Coordenada(tile_x,tile_y);
}
Objeto* reta_clippada(Objeto obj){
ListaEnc<Coordenada>* pontos = obj.pontos();
Coordenada ponto_A = *pontos->posicaoMem(0);
Coordenada ponto_B = *pontos->posicaoMem(1);
int codeA = rcCode(ponto_A);
int codeB = rcCode(ponto_B);
while(true){
if((codeA | codeB) ==0){
Objeto* novo = new Objeto(obj.nome(), obj.getTipo(), obj.isPreenchido());
novo->adiciona(ponto_A);
novo->adiciona(ponto_B);
return novo;
}
else if(codeA & codeB){
return 0;
}
else{
double novo_x, novo_y;
int rcFora = codeA ? codeA : codeB;
if (rcFora & 8) { // point is above the clip rectangle
novo_x = ponto_A.getX() + (ponto_B.getX() - ponto_A.getX()) * (1 - ponto_A.getY()) / (ponto_B.getY() - ponto_A.getY());
novo_y = 1;
} else if (rcFora & 4) { // point is below the clip rectangle
novo_x = ponto_A.getX() + (ponto_B.getX() - ponto_A.getX()) * (-1 - ponto_A.getY()) / (ponto_B.getY() - ponto_A.getY());
novo_y = -1;
} else if (rcFora & 2) { // point is to the right of clip rectangle
novo_y = ponto_A.getY() + (ponto_B.getY() - ponto_A.getY()) * (1 - ponto_A.getX()) / (ponto_B.getX() - ponto_A.getX());
novo_x = 1;
} else if (rcFora & 1) { // point is to the left of clip rectangle
novo_y = ponto_A.getY() + (ponto_B.getY() - ponto_A.getY()) * (-1 - ponto_A.getX()) / (ponto_B.getX() - ponto_A.getX());
novo_x = -1;
}
if (rcFora == codeA) {
ponto_A = Coordenada(novo_x, novo_y, 1);
codeA = rcCode(ponto_A);
} else {
ponto_B = Coordenada(novo_x, novo_y, 1);
codeB = rcCode(ponto_B);
}
}
}
}
void GameProyecto:: update()
{
int asteroidePeque;
int asteroideGrande;
for(int i=0; i < asteroides.size(); i++) {
Coordenada centro = asteroides[i].obtenCentro();
if((centro.obtenerX()>650 || centro.obtenerX() <-50) || (centro.obtenerY()>850 || centro.obtenerY() <-50))
{
centro = Coordenada(((double)600+rand()%50),(double)800+ rand()%50);
if(((int)(centro.obtenerX()))%2==0) centro = Coordenada(-centro.obtenerX()+600,centro.obtenerY());
if(((int)(centro.obtenerY()))%2==0) centro = Coordenada(centro.obtenerX(),-centro.obtenerY()+800);
asteroides[i].desplazamiento = Vector2D((float)rand(),(float)rand());
if(((int)asteroides[i].desplazamiento.getX())%3==0) asteroides[i].desplazamiento.setX(-asteroides[i].desplazamiento.getX());
if(((int)asteroides[i].desplazamiento.getY())%3==0) asteroides[i].desplazamiento.setY(-asteroides[i].desplazamiento.getY());
asteroides[i].desplazamiento.normaliza();
}
asteroides[i].posicionaCentro(Coordenada(centro.obtenerX()+ 1000/asteroides[i].calcArea()*asteroides[i].desplazamiento.getX(), centro.obtenerY() + 1000/asteroides[i].calcArea()*asteroides[i].desplazamiento.getY()));
asteroides[i].rota(1000/asteroides[i].calcArea());
for(int j = 0 ; j<i ; j++)
{
centro = asteroides[j].obtenCentro();
if((centro.obtenerX()>600 || centro.obtenerX() <0) || (centro.obtenerY()>800 || centro.obtenerY() <0))
continue;
if(asteroides[i].choca(&asteroides[j]))
{
if(asteroides[j].calcArea()>asteroides[i].calcArea())
{
asteroidePeque = i;
asteroideGrande = j;
}
else
{
asteroidePeque = j;
asteroideGrande = i;
}
asteroides[asteroideGrande].desplazamiento = Vector2D(asteroides[asteroideGrande].desplazamiento.getX() + asteroides[asteroidePeque].desplazamiento.getX()*2, asteroides[asteroideGrande].desplazamiento.getY()+ asteroides[asteroidePeque].desplazamiento.getY()*2);
asteroides[asteroideGrande].desplazamiento.normaliza();
centro = Coordenada(((double)600+rand()%50),(double)800+ rand()%50);
if(((int)(centro.obtenerX()))%2==0) centro = Coordenada(-centro.obtenerX()+600,centro.obtenerY());
if(((int)(centro.obtenerY()))%2==0) centro = Coordenada(centro.obtenerX(),-centro.obtenerY()+800);
asteroides[asteroidePeque].desplazamiento = Vector2D((float)rand(),(float)rand());
if(((int)asteroides[asteroidePeque].desplazamiento.getX())%3==0) asteroides[asteroidePeque].desplazamiento.setX(-asteroides[asteroidePeque].desplazamiento.getX());
if(((int)asteroides[asteroidePeque].desplazamiento.getY())%3==0) asteroides[asteroidePeque].desplazamiento.setY(-asteroides[asteroidePeque].desplazamiento.getY());
asteroides[asteroidePeque].desplazamiento.normaliza();
asteroides[asteroidePeque].posicionaCentro(Coordenada(centro.obtenerX()+ 1000/asteroides[asteroidePeque].calcArea()*asteroides[asteroidePeque].desplazamiento.getX(), centro.obtenerY() + 1000/asteroides[asteroidePeque].calcArea()*asteroides[asteroidePeque].desplazamiento.getY()));
}
}
}
}
Coordenada Calculador::calcularPosicionRelativa(Coordenada coord_tile, Coordenada coord_ceros_pixel){
int x_nuevo, y_nuevo;
//Posicionamiento en el eje y relativo
x_nuevo = coord_ceros_pixel.x - coord_tile.y * DISTANCIA_ENTRE_X;
y_nuevo = coord_ceros_pixel.y + coord_tile.y * DISTANCIA_ENTRE_Y;
//posicionamiento en el eje x relativo
x_nuevo = x_nuevo + coord_tile.x * DISTANCIA_ENTRE_X;
y_nuevo = y_nuevo + coord_tile.x * DISTANCIA_ENTRE_Y;
return Coordenada(x_nuevo,y_nuevo);
}
void ConfiguracionMapa::crearCeldas(){
double incrementoLongitud = (longitudDerecha - longitudIzquierda) / ancho;
double incrementoLatitud = (latitudSuperior - latitudInferior) / alto;
for (int alto = this->alto - 1; alto >= 0; alto--){
double latitudCentro = latitudInferior + incrementoLatitud * alto +
(incrementoLatitud / 2);
for (int ancho = 0; ancho < this->ancho; ancho++){
double longitudCentro = longitudIzquierda +
incrementoLongitud * ancho + (incrementoLongitud / 2);
celdas.push_back(new Celda(
Coordenada(longitudCentro, latitudCentro), &calle));
}
}
}
Matriz matrizTransformacaoCanvas() {
double radianos = vupVector.angleWith(Coordenada(0, 1, 0));
double angulo = radianos / PI * 180.0;
// gambi do joão pra fazer funcionar a rotação total e não só meia lua :v
if (vupVector._x < 0) {
angulo = 360 - angulo;
}
// move pro centro
Matriz matrizTranslacaoNeg = MatrizUtil::matrizTranslacao3D(_centro.negativa());
// rotaciona novamente pra vertical
Matriz matrizRotacao = MatrizUtil::matrizRotacao3DZ(angulo);
Matriz matrizTranslacao = MatrizUtil::matrizTranslacao3D(_centro);
return matrizTranslacaoNeg * matrizRotacao * matrizTranslacao;
}
void GameProyecto:: init(char* titulo ="Hola Mundo",int xpos = 0, int ypos = 0 , int alto = 100, int ancho = 100 , int banderas = 0, int cantAsteroides=100
)
{
if (SDL_Init(SDL_INIT_EVERYTHING) != 0){
std::cout << "SDL_Init Error: " << SDL_GetError() << std::endl;
m_bRunning = false;
}
m_pWindow = SDL_CreateWindow(titulo, xpos, ypos, alto, ancho, banderas);
if (m_pWindow == nullptr){
std::cout << "SDL_CreateWindow Error: " << SDL_GetError() << std::endl;
m_bRunning = false;
}
m_pRenderer = SDL_CreateRenderer(m_pWindow, -1, SDL_RENDERER_ACCELERATED |
SDL_RENDERER_PRESENTVSYNC);
if (m_pRenderer == nullptr){
std::cout << "SDL_CreateRenderer Error: " << SDL_GetError() << std::endl;
m_bRunning = false;
}
bmp = SDL_LoadBMP("./hello.bmp");
if (bmp == nullptr){
std::cout << "SDL_LoadBMP Error: " << SDL_GetError() << std::endl;
m_bRunning= false;
}
tex = SDL_CreateTextureFromSurface(m_pRenderer, bmp);
SDL_FreeSurface(bmp);
if (tex == nullptr){
std::cout << "SDL_CreateTextureFromSurface Error: " << SDL_GetError() << std::endl;
m_bRunning = false;
}
for(int i = 0 ; i<cantAsteroides ; i++)
{
srand (i);
int lados = (rand()%10 + rand()%15)%10 + 10;
long double radio = rand()%15 + rand()%25 +10;
asteroides.push_back(Asteroide(lados,radio));
asteroides.back().posicionaCentro(Coordenada((rand()%600),rand()%800));
}
}
Coordenada Calculador::obtenerCoordenadaLibreCercaDeEdificio(Edificio* edificio,Escenario* escenario){
Coordenada c_edificio = edificio->getPosicion();
pair<int,int> tam = edificio->getTam();
int max_distancia = 3;
int x_ini = c_edificio.x - max_distancia;
int y_ini = c_edificio.y - max_distancia;
int x_fin = c_edificio.x+tam.first+max_distancia;
int y_fin = c_edificio.y+tam.second+max_distancia;
Coordenada c_inicial(x_ini, y_ini);
Coordenada c_final(x_fin, y_fin);
for (Coordenada c1 = c_inicial; c1.y <= c_final.y; c1.y++){
for (Coordenada c2 = c1; c2.x <= c_final.x; c2.x++){
if (puntoContenidoEnEscenario(c2,escenario)){
Tile* tile = escenario->getTile(c2);
if (tile->estaLibre())
return c2;
}
}
}
return Coordenada(-1,-1);
}
void SpriteUnidad::update(int vel_personaje, Mix_Chunk* sonido_caminar){
verificarEstadoEntidadConImagen();
switch (entidad->getEstado()){
case MURIENDO :
if (indexSpriteActual+1 == FRAMES_MUERTE)
entidad->cambioEstado(MUERTO);
break;
//default : //break;
case CAMINANDO:
if (this->quedaCaminoPorRecorrer()) {
// Activo sonido del movimiento:
Mix_PlayChannel(1, sonido_caminar, 0);
/* - calcular distancia al sig punto
* - si es mayor a 1, seguir moviendo la posicion
* sino cambiar al siguiente punto del camino (analizando la dirección)
* - si ya no quedan camino a recorrer, cambiar estado de activar movimiento y acomodar
* */
Coordenada c_prox_pixel = this->getCaminoARecorrer()[0];
c_prox_pixel.x -= this->getPosicion().w / 2;
c_prox_pixel.y -= this->getPosicion().h;
float distancia = Calculador::calcularDistanciaEntrePixeles(Coordenada(this->regPos.posX_player, this->regPos.posY_player), c_prox_pixel);
if (distancia > 1){
if (this->regPos.posX_player != c_prox_pixel.x) {
float x_result = (this->regPos.posX_player - ((this->regPos.posX_player - c_prox_pixel.x) / distancia) * vel_personaje * 0.05);
this->setPosX(int(x_result));
this->regPos.posX_player = x_result;
}
if (this->regPos.posY_player != c_prox_pixel.y) {
float y_result = (this->regPos.posY_player - ((this->regPos.posY_player - c_prox_pixel.y) / distancia) * vel_personaje * 0.05);
this->setPosY(int(y_result));
this->regPos.posY_player = y_result;
}
} else {
/* guardar última coordenada para desocuparla y cambiar a la próxima */
Coordenada c_ult_punto = this->getCaminoARecorrer()[0];
this->quitarPrimeraCoordenada();
/* Seteamos la dirección para el siguiente punto. */
if (this->getCaminoARecorrer().size() > 0){
try {
//this->escenario->desocuparTile(Calculador::tileParaPixel(c_ult_punto, coord_ceros));
if (this->revisarCamino(c_ult_punto)) {
Coordenada c_prox_punto = this->getCaminoARecorrer()[0];
c_prox_punto.x -= this->getPosicion().w / 2;
c_prox_punto.y -= this->getPosicion().h / 2;
Coordenada c_tile_actual = Calculador::tileParaCualquierPixel(coordPixelSprite(),coord_ceros);
Coordenada c_tile_prox = Calculador::tileParaCualquierPixel(c_prox_punto,coord_ceros);
if (c_tile_actual != c_tile_prox){
Direccion direccion = Calculador::calcularDireccionEntrePuntosAdyacentes(c_tile_actual,c_tile_prox);
this->setDireccion(direccion);
}
//Direccion direccion = Calculador::calcularDireccion(c_prox_punto, coordPixelSprite());
//this->setDireccion(direccion);
}
} catch ( FueraDeEscenario &e ) { setearNuevoCamino(Camino(), coord_ceros); }
} else // Se acaba de terminar el camino, que es de un solo paso.
throw PasoCompletado(entidad->getIDJug());
}
} else {
/* Cuando se deja de mover, se debería quedar en
* una posición firme correspondiente a su dirección. */
this->activarMovimiento(false);
entidad->cambioEstado(QUIETO);
// Paro el sonido:
Mix_HaltChannel(1);
}
break;
default: break;//
}
/*
if (estadoSprite != QUIETO){
if (currentTime() > (1000/getFps())){
efectuarMovimiento();
}
}
*/
// bool hayColision = DetectorDeColisiones::verificarColisiones(this,juego->getSpritesEntidades());
// if (hayColision) this->activarMovimiento(false);
}
// No lanza FueraDeEscenario.
Coordenada Calculador::pixelCentralDeCualquierTile(Coordenada coord_tile, Coordenada coord_ceros) {
int pix_x = coord_ceros.x + (coord_tile.x - coord_tile.y) * DISTANCIA_ENTRE_X;
int pix_y = coord_ceros.y + (1 + coord_tile.x + coord_tile.y) * DISTANCIA_ENTRE_Y;
return Coordenada(pix_x, pix_y);
}
void clip_Poligono(Objeto obj, DisplayFile* virt_clip){
//CHANCE DE DAR MERDA EM TUDO POR COMPARAR IGUALDADE ENTRE DOUBLES
//Inicializando as 3 listas
ListaEnc<Coordenada> pontos_obj;
ListaEnc<Coordenada> pontos_obj_ori;//usado para percorrer os pontos do objeto. pontos_obj será modificado.
ListaEnc<Coordenada> pontos_window;
ListaEnc<Coordenada> pontos_window_ori;
ListaEnc<Coordenada> entrantes;
ListaEnc<Coordenada>* pontos_obj_ = obj.pontos();
for(int i =0; i<pontos_obj_->getSize();i++){
pontos_obj.adiciona(*pontos_obj_->posicaoMem(i));
pontos_obj_ori.adiciona(*pontos_obj_->posicaoMem(i));
}
pontos_window.adiciona(Coordenada(-1,-1,1));
pontos_window.adiciona(Coordenada(-1,1,1));
pontos_window.adiciona(Coordenada(1,1,1));
pontos_window.adiciona(Coordenada(1,-1,1));
pontos_window_ori.adiciona(Coordenada(-1,-1,1));
pontos_window_ori.adiciona(Coordenada(-1,1,1));
pontos_window_ori.adiciona(Coordenada(1,1,1));
pontos_window_ori.adiciona(Coordenada(1,-1,1));
bool gambiarraTudoDentro = true;
//percorrendo os segmentos de reta do polígono e montando as 3 listas
Elemento<Coordenada>* it_objeto = pontos_obj_ori.getHead();
for(int i =0; i<pontos_obj_ori.getSize();i++){
Coordenada pontoA = *pontos_obj_ori.posicaoMem(i);
Coordenada pontoB = *pontos_obj_ori.posicaoMem((i+1) % (pontos_obj_ori.getSize()));
it_objeto = it_objeto->_next;
if(rcCode(pontoA)==0){ // A dentro;
if(rcCode(pontoB)!=0){ //pontoB fora;
//caso dentro-fora
Objeto reta(" ", Reta, false);
reta.adiciona(pontoA);
reta.adiciona(pontoB);
Objeto *nova_reta = reta_clippada(reta);
ListaEnc<Coordenada>* pontos_reta = nova_reta->pontos();
Coordenada novoB = *pontos_reta->posicaoMem(1);//pode dar problema de índice;
insereNaWindow(&pontos_window, novoB);
insereNoObjeto(&pontos_obj, pontoA, novoB);
gambiarraTudoDentro = false;
}else{
// cout << "dentro dentro" << endl;
}
}
else{
gambiarraTudoDentro = false;
Objeto reta(" ", Reta, false);
reta.adiciona(pontoA);
reta.adiciona(pontoB);
Objeto *nova_reta = reta_clippada(reta);
if(rcCode(pontoB)==0){ //pontoB dentro;
//caso fora-dentro;
ListaEnc<Coordenada>* pontos_reta = nova_reta->pontos();
Coordenada novoA = *pontos_reta->posicaoMem(0);//pode dar problema de índice;
insereNaWindow(&pontos_window, novoA);
insereNoObjeto(&pontos_obj, pontoA, novoA);
entrantes.adiciona(novoA);
}
else{
//caso fora-fora
if(nova_reta==0){
continue;
}
//cortando 2 pontos da window:
ListaEnc<Coordenada>* pontos_reta = nova_reta->pontos();
Coordenada novoA = *pontos_reta->posicaoMem(0);//pode dar problema de índice;
Coordenada novoB = *pontos_reta->posicaoMem(1);//pode dar problema de índice;
insereNaWindow(&pontos_window, novoA);
insereNaWindow(&pontos_window, novoB);
insereNoObjeto(&pontos_obj, pontoA, novoA, novoB);
entrantes.adiciona(novoA);
}
}
}
while(!entrantes.listaVazia()){
Objeto* novo = new Objeto(obj.nome(), obj.getTipo(), obj.isPreenchido());
Coordenada inicial = entrantes.retiraDoInicio();
Coordenada atual = inicial;
novo->adiciona(atual);
Coordenada* it_pontos_obj = pontos_obj.posicaoMem(0);
Coordenada* it_pontos_window = pontos_window.posicaoMem(0);
//ajustando iteradores para as posićões corretas.
bool varreWindow =false;
int fuck1=0, fuck2=0;
do{
if(varreWindow){
while(!igual(it_pontos_window->getX(), atual.getX()) || !igual(it_pontos_window->getY(),atual.getY())){
it_pontos_window = pontos_window.posicaoMem(fuck1);
fuck1 = (fuck1+1) % pontos_window.getSize();
}
it_pontos_window = pontos_window.posicaoMem(fuck1);
fuck1 = (fuck1+1) % pontos_window.getSize();
atual = *it_pontos_window;
// cout << "adicionou" << endl;
cout<< atual.getX() << ", " << atual.getY() << endl;
novo->adiciona(atual);
if(gambs_pontoPertence(pontos_window_ori, atual)){
continue;
}
varreWindow = false;
}
else{
while(!igual(it_pontos_obj->getX(), atual.getX()) || !igual(it_pontos_obj->getY(),atual.getY())){
it_pontos_obj = pontos_obj.posicaoMem(fuck2);
fuck2 = (fuck2+1) % pontos_obj.getSize();
}
it_pontos_obj = pontos_obj.posicaoMem(fuck2);
fuck2 = (fuck2+1) % pontos_obj.getSize();
atual = *it_pontos_obj;
novo->adiciona(atual);
if(gambs_pontoPertence(pontos_window, atual)){
varreWindow = true;
continue;
}
if(gambs_pontoPertence(pontos_obj_ori, atual)){
continue;
}
varreWindow = true;
}
}while(!igual(atual.getX(), inicial.getX()) || !igual(atual.getY(), inicial.getY()));//atual!=inicial
virt_clip->adiciona(novo);
}
if(gambiarraTudoDentro){
ListaEnc<Coordenada>* pontos_obj_ = obj.pontos();
Objeto* novo = new Objeto(obj.nome(), obj.getTipo(), obj.isPreenchido());
for(int i =0; i<pontos_obj_->getSize();i++){
novo->adiciona(*pontos_obj_->posicaoMem(i));
}
virt_clip->adiciona(novo);
}
}
Tile* Escenario::getTile(int x, int y){
if (!coordEnEscenario(Coordenada(x,y)))
return NULL;
return this->matriz_tiles[x][y];
}
Coordenada Calculador::generarPosRandomDentroDeEscenarioConLimites(int size_x, int x_max, int x_min, int size_y, int y_max, int y_min) {
Coordenada c = generarPosRandom(x_max, x_min, y_max, y_min);
return Coordenada(ChequeoDeBorde(size_x, c.x), ChequeoDeBorde(size_y, c.y));
}
