Neverland

Neverland.Rework

Добавлен Nerevar, опубликован

Переписал тут на днях код,завернув в классы и для удобства,набросав базовую архитектуру и добавив некоторый функционал

Скрин,на котором мало что изменилось

В архиве также приложен исходный код,если кто захочет поиграться или добавить чего своего или просто любопытно посмотреть

Для совсем ленивых исходный код под катами

Game.cpp

#include "ResManager.h"
#include "UnitManager.h"
#include "CellManager.h"

class Game
{
public:
	int State;

	ResManager resManager;
	UnitManager unitManager;
	CellManager cellManager;

	Clock clock;
	int elapsed;

	VideoMode videomode;
	RenderWindow window;
	View defaultView;
	View currView;

	Input input;

	Sprite cursor;
	Vector2f cursorPos;

void Init()
{
	State=1;
	srand(time(0));
	videomode=videomode.getDesktopMode();
	defaultView.reset(FloatRect(0, 0, videomode.width, videomode.height));
	currView.reset(FloatRect(0, 0, videomode.width, videomode.height));
	window.create(videomode, "Neverland",Style::Default);
	window.setView(currView);
	window.setMouseCursorVisible(false);

	resManager.LoadFont("arial.ttf");

	resManager.Load(Textures::Skeleton,"skeleton5.png");
	resManager.Load(Textures::Cursor,"cursor.png");
	resManager.Load(Textures::Tileset,"tileset.png");
	resManager.Load(Textures::Hero,"hero.png");
	
	cursor.setTexture(resManager.Get(Textures::Cursor));
}

void Update()
{
	 Event event;

	 if (Keyboard::isKeyPressed(Keyboard::Escape))
			{
				window.setMouseCursorVisible(true);
				window.close();
			}
     while (window.pollEvent(event))
        {
			switch(event.type)
			{

			// отлавливаем,нажато ли что-нибудь
			case Event::KeyPressed:
			case Event::KeyReleased:
			case Event::MouseButtonPressed:
			case Event::MouseButtonReleased:
			case Event::MouseMoved:
			input.CheckInput();
			break;

			//отлавливаем,произошло ли события закрытия
			case Event::Closed:
			window.setMouseCursorVisible(true);
            window.close();
			}
			
        }

		cursorPos=window.mapPixelToCoords(Vector2i(input.MouseX,input.MouseY));
		cursor.setPosition(Vector2f(int(cursorPos.x/64)*64,int(cursorPos.y/64)*64));

		elapsed = elapsed+clock.restart().asMilliseconds();

		currView.setCenter(currView.getCenter()+input.UpdateView());
		window.setView(currView);


		input.ClearInput();
		
        
}

void Draw()
{
	window.clear();

	window.draw(cellManager.tileMap);
	unitManager.Draw(window);
	unitManager.DrawUnitText(window);
	window.draw(cursor);
	window.display();
}


};

main.cpp

#include "main.h"
#include "Game.cpp"


int main()
{
	Game game;
	game.Init();
	
	game.cellManager.GenCells();

	game.cellManager.tileMap.LoadTileMap(game.resManager,Textures::Tileset,Vector2u(64,64),100,100);

	game.unitManager.LoadUnit(game.resManager,Textures::Hero,"Nerevar",64,64,100,game.resManager.MainFont);
	game.unitManager.LoadUnit(game.resManager,Textures::Skeleton,"Skeleton",128,128,100,game.resManager.MainFont);
	

for (unsigned int i=0;i<game.unitManager.count;i++)
{
	if (game.cellManager.tileMap.IsPathableCell(game.unitManager.units[i].sprite.getPosition().x/64,game.unitManager.units[i].sprite.getPosition().y/64)==0)
	{
	Vector2f v=game.cellManager.tileMap.FindPathableCell(game.unitManager.units[i].sprite.getPosition().x/64,game.unitManager.units[i].sprite.getPosition().y/64);
	game.unitManager.units[i].sprite.setPosition(v.x*64,v.y*64);
	}
}

	while (game.window.isOpen())
    {

		game.Update();

		game.Draw();

    }
	

    return 0;
}

main.h

#ifndef MAIN_H
#define MAIN_H

#include <SFML/Graphics.hpp>
#include <iostream>
#include <ctime>
#include <vector>
#include <map>
#include <memory>

using namespace std;
using namespace sf;

#define GetRandomInt(min,max) rand() % ((max + 1) - min) + min;

namespace Textures
{
	enum ID { Hero , Skeleton ,  Cursor ,Tileset };
}

class Input
{
public:
	unsigned int Up,Down,Left,Right;
	unsigned int MouseLeft,MouseRight;
	unsigned int MouseX,MouseY;
	unsigned int Esc,Enter;

Input()
{
	Up,Down,Left,Right=0;
	MouseLeft,MouseRight=0;
	Esc,Enter=0;
	MouseX=Mouse::getPosition().x;
	MouseY=Mouse::getPosition().y;
}
Vector2f UpdateView()
{
	Vector2f update=Vector2f(0,0);
	if (Up!=0)
	{
		update=Vector2f(0,-64);

	}
	if (Down==1)
	{
		update=Vector2f(0,64);
	}
	if (Left==1)
	{
		update=Vector2f(-64,0);
	}
	if (Right==1)
	{
		update=Vector2f(64,0);
	}
	return update;
}
void CheckInput()
{
	Up=Keyboard::isKeyPressed(Keyboard::W);
	Down=Keyboard::isKeyPressed(Keyboard::S);
	Left=Keyboard::isKeyPressed(Keyboard::A);
	Right=Keyboard::isKeyPressed(Keyboard::D);
	Esc=Keyboard::isKeyPressed(Keyboard::Escape);
	Enter=Keyboard::isKeyPressed(Keyboard::Comma);
	MouseX=Mouse::getPosition().x;
	MouseY=Mouse::getPosition().y;
}

void ClearInput()
{
	Up=0;
	Down=0;
	Left=0;
	Right=0;
	Esc=0;
	Enter=0;
}
};



#endif

Unit.h

#include "main.h"

class Unit: public Drawable, public Transformable
{
public:
	Sprite sprite;
	Texture texture;
	Text text;
	string name;
	Uint32 x;
	Uint32 y;
	Uint32 hp;

Unit(){}

void SetPosition(Uint32 newX,Uint32 newY)
{
	x=newX;
	y=newY;
}

Vector2i GetPosition()
{
	return Vector2i(x,y);
}

void DamageTarget(Unit &caster,Unit &target,float damage)
{
	target.hp=target.hp-damage;
}

virtual void draw(RenderTarget& target) const
    {
        target.draw(sprite);
    }

virtual void draw(RenderTarget& target, RenderStates states) const
    {
        // apply the transform
        states.transform *= getTransform();

        // apply the tileset texture
        states.texture = &texture;

        // draw the vertex array
        target.draw(sprite, states);
    }

};

Cell.h

#include "main.h"
#include "ResManager.h"

class Cell
{
public:
	unsigned int pathable;
	unsigned int x,y;
	unsigned int textureId;
	Cell(){}

Cell(unsigned int _pathable,unsigned int _x,unsigned int _y,unsigned int _textureId)
{
	pathable=_pathable;
	x=_x;
	y=_y;
	textureId=_textureId;
}

};

class TileMap : public Drawable, public Transformable
{
public:
	VertexArray vertices;
    Texture texture;
	Vector2u tileSize; 
	unsigned int width;
	unsigned int height;
	vector<Cell> cells;

unsigned int IsPathableCell(int x,int y)
{
	return cells[y*width+x].pathable;
}

Vector2f FindPathableCell(int x,int y)
{
	int tx=x;
	int ty=y;
	while(IsPathableCell(tx,ty)==0)
{
	int random=GetRandomInt(0,4);

	if (random==0&&tx+1<100&&ty+1<100)
	{
		tx=tx+1;
		ty=ty+1;
	}
	else if (random==1&&tx-1>=0&&ty-1>=0)
	{
		tx=tx-1;
		ty=ty-1;
	}
	else if (random==2&&tx+1<100&&ty-1>=0)
	{
		tx=tx+1;
		ty=ty-1;
	}
	else if (random==3&&tx-1>=0&&ty+1<100)
	{
		tx=tx-1;
		ty=ty+1;
	}
	else if (random==4&&tx-1>=0&&ty-1>=0)
	{
		tx=tx-1;
		ty=ty-1;
	}
}
	return Vector2f(tx,ty);
}



bool UpdateCell(int x,int y,unsigned int newPathable,unsigned int newTextureId)
	{
		cells[y*width+x].pathable=newPathable;
		cells[y*width+x].textureId=newTextureId;

		int tu = cells[y*width+x].textureId % (texture.getSize().x / tileSize.x);
        int tv = cells[y*width+x].textureId / (texture.getSize().x / tileSize.x);

		Vertex* quad = &vertices[(x + y * width) * 4];

		// define its 4 texture coordinates
        quad[0].texCoords = Vector2f(tu * tileSize.x, tv * tileSize.y);
        quad[1].texCoords = Vector2f((tu + 1) * tileSize.x, tv * tileSize.y);
        quad[2].texCoords = Vector2f((tu + 1) * tileSize.x, (tv + 1) * tileSize.y);
        quad[3].texCoords = Vector2f(tu * tileSize.x, (tv + 1) * tileSize.y);
		return true;
	}

bool LoadTileMap(ResManager &resManager,Textures::ID id, Vector2u _tileSize,  unsigned int _width, unsigned int _height)
{
		tileSize=_tileSize;
		width=_width;
		height=_height;

		texture=resManager.Get(id);

        vertices.setPrimitiveType(Quads);
        vertices.resize(width * height * 4);

        for (unsigned int i = 0; i < width; ++i)
            for (unsigned int j = 0; j < height; ++j)
            {
				int tileNumber = cells[i + j * width].textureId;

                int tu = tileNumber % (texture.getSize().x / tileSize.x);
                int tv = tileNumber / (texture.getSize().x / tileSize.x);

                Vertex* quad = &vertices[(i + j * width) * 4];

                quad[0].position = Vector2f(i * tileSize.x, j * tileSize.y);
                quad[1].position = Vector2f((i + 1) * tileSize.x, j * tileSize.y);
                quad[2].position = Vector2f((i + 1) * tileSize.x, (j + 1) * tileSize.y);
                quad[3].position = Vector2f(i * tileSize.x, (j + 1) * tileSize.y);

                quad[0].texCoords = Vector2f(tu * tileSize.x, tv * tileSize.y);
                quad[1].texCoords = Vector2f((tu + 1) * tileSize.x, tv * tileSize.y);
                quad[2].texCoords = Vector2f((tu + 1) * tileSize.x, (tv + 1) * tileSize.y);
                quad[3].texCoords = Vector2f(tu * tileSize.x, (tv + 1) * tileSize.y);
            }

        return true;
}

virtual void draw(RenderTarget& target, RenderStates states) const
    {
        
        states.transform *= getTransform();

        states.texture = &texture;

        target.draw(vertices, states);
    }
    
};

UnitManager.h

#include "main.h"
#include "Unit.h"
#include "ResManager.h"

class UnitManager
{
public:
	vector<Unit> units;
	unsigned int count;

UnitManager()
{
	count=0;
}

void DrawUnitText(RenderTarget& target)
{
	for (unsigned int i=0;i<count;i++)
	{
		int dx=units[i].text.getLocalBounds().width/2;

	units[i].text.setPosition(units[i].sprite.getPosition().x+32-dx,units[i].sprite.getPosition().y-20);
	target.draw(units[i].text);
	}
}

void Draw(RenderTarget& target) const
    {
		for (unsigned int i=0;i<count;i++)
		{
			units[i].draw(target);
		}
	}
  
void LoadUnit(ResManager &resManager,Textures::ID id,const string &_name,Uint32 _x,Uint32 _y,Uint32 _hp,Font &font)
{
	Unit unit;
	unit.sprite.setTexture(resManager.Get(id));
	unit.sprite.setPosition(_x,_y);
	unit.name=_name;
	unit.x=_x;
	unit.y=_y;
	unit.hp=_hp;
	unit.text.setFont(font);
	unit.text.setString(unit.name);	
	unit.text.setCharacterSize(16); 
	unit.text.setColor(Color::White);

	units.push_back(unit);
	count=count+1;
}

};

CellManager.h

#include "main.h"
#include "Cell.h"

class CellManager
{

public:
	TileMap tileMap;

void GenCells()
{
	int x=0,y=0;
	for (unsigned int i=0;i<10000;i++)
	{
			if (x<19)
			{
				x=x+1;
			}
			else
			{
				x=0;
			}
			
			if (i%19==0)
			{
				y=y+1;
			}
			
			int random=GetRandomInt(0,2);
			if (random==0)
			{
				tileMap.cells.push_back(Cell(1,x,y,0));
			}
			else if (random==1)
			{
				tileMap.cells.push_back(Cell(1,x,y,1));
			}
			else if (random==2)
			{
				tileMap.cells.push_back(Cell(0,x,y,2));
			}
	}
}
};

ResManager.h

#include "main.h"

#ifndef RESMANAGER_H
#define RESMANAGER_H
class ResManager
{
public:

	map<Textures::ID,unique_ptr<Texture>>TextureMap;
	vector <Texture> Textures;
	Font MainFont;

bool LoadFont(const string &Name)
{
	return MainFont.loadFromFile(Name);
}

void Load(Textures::ID id, const string& filename)
{
	unique_ptr<Texture> texture(new Texture());
	texture->loadFromFile(filename);
	TextureMap.insert(make_pair(id, move(texture)));
}

Texture& Get(Textures::ID id)
{
auto found = TextureMap.find(id);
return *found->second;
}


};

#endif

GameDev

Скачать - 846 КБ 250

ОЖИДАНИЕ РЕКЛАМЫ...

Nerevar 10 лет назад

Мнения мимо-проходящих мастеров cpp приветствуются

Doc 10 лет назад

Лучше бы сурсы на гитхаб залил или куда-нибудь еще

SageOne 10 лет назад
Отредактирован SageOne

слишком много эччи, имхо

Этот комментарий удален

Чтобы оставить комментарий, пожалуйста, войдите на сайт.

Выбор редакции

Neverland.Rework

Вход

Регистрация на сайте

Переместить ресурс 移动资源

Создание задания

Выбор проекта для репоста

Управление интересами