Merge pull request #190 from devZoGok/ft-144-player-trading

Ft 144 player trading

Assets/Models/Maps/aaa/aaa.lua

@@ -9,23 +9,38 @@ numPlayers = 1,
 numSpawnPoints = 1,
 spawnPoints = {
 {x = 0.000000, y = 0.000000, z = 0.000000},
+{x = 170.000000, y = 0.000000, z = -170.000000},
 {x = -170.000000, y = 0.000000, z = 170.000000},
 },
 players = {
-{
-resourceDeposits = {
-	{id = 0, pos = {x = -150.000000, y = 0.000000, z = 150.000000}, rot = {w = 1.000000, x = 0.000000, y = 0.000000, z = 0.000000}, initAmmount = 1000},
-},
-units = {
-	{id = UnitId.WAR_MECH, pos = {x = 100.000000, y = 0.000000, z = 10.000000}, rot = {w = 1.000000, x = 0.000000, y = 0.000000, z = 0.000000}, buildStatus = 100},
-}
-},
-{
-	resourceDeposits = {},
-	units = {
-		{id = UnitId.ENGINEER, pos = {x = -170.000000, y = 0.000000, z = 150.000000}, rot = {w = 1.000000, x = 0.000000, y = 0.000000, z = 0.000000}},
-	}
-}
+	{
+		resourceDeposits = {
+			{id = 0, pos = {x = -150.000000, y = 0.000000, z = 150.000000}, rot = {w = 1.000000, x = 0.000000, y = 0.000000, z = 0.000000}, initAmmount = 1000},
+		},
+		units = {
+			{id = UnitId.WAR_MECH, pos = {x = -170.000000, y = 0.000000, z = 150.000000}, rot = {w = 1.000000, x = 0.000000, y = 0.000000, z = 0.000000}},
+			{id = UnitId.RESOURCE_ROVER, pos = {x = -170.000000, y = 0.000000, z = 180.000000}, rot = {w = 1.000000, x = 0.000000, y = 0.000000, z = 0.000000}},
+			{id = UnitId.TRADE_CENTER, pos = {x = -180.000000, y = 0.000000, z = 150.000000}, rot = {w = 1.000000, x = 0.000000, y = 0.000000, z = 0.000000}, buildStatus = 100},
+			{id = UnitId.LAB, pos = {x = -200.000000, y = 0.000000, z = 140.000000}, rot = {w = 1.000000, x = 0.000000, y = 0.000000, z = 0.000000}, buildStatus = 100},
+			{id = UnitId.REFINERY, pos = {x = -170.000000, y = 0.000000, z = 120.000000}, rot = {w = 1.000000, x = 0.000000, y = 0.000000, z = 0.000000}, buildStatus = 100},
+		}
+	},
+	{
+		resourceDeposits = {},
+		units = {
+			{id = UnitId.POINT_DEFENSE, pos = {x = 100.000000, y = 0.000000, z = 10.000000}, rot = {w = 1.000000, x = 0.000000, y = 0.000000, z = 0.000000}, buildStatus = 100},
+			{id = UnitId.RESOURCE_ROVER, pos = {x = 100.000000, y = 0.000000, z = -10.000000}, rot = {w = 1.000000, x = 0.000000, y = 0.000000, z = 0.000000}},
+			{id = UnitId.TRADE_CENTER, pos = {x = 130.000000, y = 0.000000, z = 10.000000}, rot = {w = 1.000000, x = 0.000000, y = 0.000000, z = 0.000000}, buildStatus = 100},
+			{id = UnitId.LAB, pos = {x = 100.000000, y = 0.000000, z = 20.000000}, rot = {w = 1.000000, x = 0.000000, y = 0.000000, z = 0.000000}, buildStatus = 100},
+			{id = UnitId.REFINERY, pos = {x = 100.000000, y = 0.000000, z = 50.000000}, rot = {w = 1.000000, x = 0.000000, y = 0.000000, z = 0.000000}, buildStatus = 100},
+		}
+	},
+	{
+		resourceDeposits = {},
+		units = {
+			{id = UnitId.LAND_FACTORY, pos = {x = 170.000000, y = 0.000000, z = -170.000000}, rot = {w = 1.000000, x = 0.000000, y = 0.000000, z = 0.000000}, buildStatus = 100},
+		}
+	},
 },
 numCells = 3969,
 cells = {

Assets/Scripts/GameObjects/Units/unitData.lua

@@ -1,14 +1,16 @@
 OrderType = {
-	HALT = -1, 
-	ATTACK = 0, 
-	BUILD = 1, 
-	MOVE = 2, 
-	GARRISON = 3, 
-	EJECT = 4, 
-	PATROL = 5, 
-	LAUNCH = 6, 
-	SUPPLY = 7, 
-	HACK = 8
+	HALT = -1,
+	ATTACK = 0,
+	BUILD = 1,
+	MOVE = 2,
+	GARRISON = 3,
+	EJECT = 4,
+	PATROL = 5,
+	LAUNCH = 6,
+	SUPPLY = 7,
+	LOAD = 8,
+	UNLOAD = 9,
+	HACK = 10
 }
 UnitId = {
 	WAR_MECH = 0,
@@ -353,7 +355,11 @@ units = {
 	},
 	{
 		weapons = {},
-		abilityButtons = {{buttonType = ButtonType.ORDER, name = 'Supply', orderType = OrderType.SUPPLY}},
+		abilityButtons = {
+			{buttonType = ButtonType.ORDER, name = 'Supply', orderType = OrderType.SUPPLY},
+			{buttonType = ButtonType.ORDER, name = 'Load', orderType = OrderType.LOAD},
+			{buttonType = ButtonType.ORDER, name = 'Unload', orderType = OrderType.UNLOAD},
+		},
 		unitClass = UnitClass.RESOURCE_ROVER,
 		unitType = UnitType.HOVER,
 		armor = {ArmorType.CAST},

Assets/Scripts/Gui/main.lua

@@ -31,7 +31,7 @@ ButtonType = {
 	SELL_REFINEDS = 27,
 	BUY_RESEARCH = 28,
 	SELL_RESEARCH = 29,
-	ACTIVE_GAME_STATE = 30,
+	ACTIVE_STATE_BACK = 30,
 	PLAYER_TRADE = 31,
 	TRADING_SCREEN = 32,
 	TRADE_OFFER = 33,

Assets/Scripts/Gui/tradingHub.lua

@@ -7,6 +7,9 @@ HubMargin = {top = 10, left = 10, right = 10, bottom = 10}
 buttonSize = {x = 100, y = 20}
 textboxSize = {x = 200, y = 25}
 
+warIcon = 'Icons/PlayerStates/war.png'
+allianceIcon = 'Icons/PlayerStates/alliance.png'
+
 gui = {
 	{
 		guiType = GuiType.GUI_RECTANGLE,
@@ -16,9 +19,8 @@ gui = {
 	},
 	{
 		guiType = GuiType.BUTTON,
-		buttonType = ButtonType.ACTIVE_GAME_STATE,
+		buttonType = ButtonType.ACTIVE_STATE_BACK,
 		name = 'Back',
-		guiScreen = 'activeGameState.lua',
 		pos = {x = HubPos.x + HubSize.x - buttonSize.x - HubMargin.right, y = HubPos.y + HubSize.y - buttonSize.y - HubMargin.bottom, z = .11},
 		size = buttonSize,
 		trigger = 10

Assets/Scripts/Gui/tradingPlayerGuiTray.lua

@@ -4,8 +4,6 @@ buttonSize = {x = 100, y = 20}
 textboxSize = {x = 200, y = 20}
 
 height = HubPos.y + HubMargin.top + lineId * 30
-warIcon = 'Icons/PlayerStates/war.png'
-allianceIcon = 'Icons/PlayerStates/alliance.png'
 
 gui = {
 	{
@@ -23,7 +21,7 @@ gui = {
 		guiType = GuiType.GUI_RECTANGLE,
 		pos = {x = HubPos.x + HubMargin.left + 100, y = height, z = .11},
 		size = {x = 50, y = 50},
-		imagePath = warIcon
+		imagePath = relationsIcon
 	},
 	{
 		pos = {x = HubPos.x + HubMargin.left + 200, y = height + 25, z = .11},

Assets/Scripts/Gui/tradingScreen.lua

@@ -111,21 +111,13 @@ gui = {
 	createResourceTrayGui(false, 2, ResourceTrayGuiId.TEXTBOX),
 	createResourceTrayGui(false, 2, ResourceTrayGuiId.INCREMENT),
 	createResourceTrayGui(false, 2, ResourceTrayGuiId.DECREMENT),
-	createResourceTrayGui(true, 3, ResourceTrayGuiId.ICON, IconPath.TIME),
-	createResourceTrayGui(true, 3, ResourceTrayGuiId.TEXTBOX),
-	createResourceTrayGui(true, 3, ResourceTrayGuiId.INCREMENT),
-	createResourceTrayGui(true, 3, ResourceTrayGuiId.DECREMENT),
-	createResourceTrayGui(false, 3, ResourceTrayGuiId.ICON, IconPath.TIME),
-	createResourceTrayGui(false, 3, ResourceTrayGuiId.TEXTBOX),
-	createResourceTrayGui(false, 3, ResourceTrayGuiId.INCREMENT),
-	createResourceTrayGui(false, 3, ResourceTrayGuiId.DECREMENT),
 
 	{
 		guiType = GuiType.BUTTON,
 		buttonType = ButtonType.PLAYER_TRADE,
 		name = 'Back',
 		guiScreen = 'tradingHub.lua',
-		pos = {x = HubPos.x + HubSize.x - 2 * buttonSize.x - HubMargin.right, y = HubPos.y + HubSize.y - buttonSize.y - HubMargin.bottom, z = .2},
+		pos = {x = HubPos.x + HubSize.x - 3 * buttonSize.x - HubMargin.right, y = HubPos.y + HubSize.y - buttonSize.y - HubMargin.bottom, z = .2},
 		size = buttonSize,
 		trigger = 10
 	},

CMakeLists.txt

@@ -17,7 +17,7 @@ cmake_policy(SET CMP0015 NEW)
 
 set(UNIT_BUTTONS unitButton.cpp tradeButton.cpp buildButton.cpp trainButton.cpp researchButton.cpp orderButton.cpp stateToggleButton.cpp)
 set(OPTIONS_BUTTONS optionsButton.cpp tabButton.cpp okButton.cpp defaultsButton.cpp)
-set(TRADING_BUTTONS playerTradeButton.cpp tradingScreenButton.cpp offerButton.cpp resourceAmmountButton.cpp)
+set(TRADING_BUTTONS activeStateBackButton.cpp playerTradeButton.cpp tradingScreenButton.cpp offerButton.cpp resourceAmmountButton.cpp)
 set(MENU_BUTTONS mainMenuButton.cpp singlePlayerButton.cpp exitButton.cpp backButton.cpp playButton.cpp)
 set(MAP_EDITOR_BUTTONS mapEditorButton.cpp newMapButton.cpp loadMapButton.cpp exportButton.cpp)
 set(BUTTONS statsButton.cpp activeStateButton.cpp minimapButton.cpp ${TRADING_BUTTONS} ${OPTIONS_BUTTONS} ${MENU_BUTTONS} ${MAP_EDITOR_BUTTONS} ${UNIT_BUTTONS})

activeGameState.cpp

@@ -30,6 +30,7 @@
 #include "unitButton.h"
 #include "extractor.h"
 #include "resourceDeposit.h"
+#include "resourceRover.h"
 #include "concreteGuiManager.h"
 
 using namespace vb01;
@@ -133,7 +134,8 @@ namespace battleship{
 		cursorNode->setPosition(Vector3(cursorPos.x, cursorPos.y, .8));
 
 		if(mainPlayer->getNumSelectedUnits() > 0){
-			bool ownGameObj = (gameObjHoveredOn && gameObjHoveredOn->getPlayer()->getTeam() == mainPlayer->getTeam());
+			bool ownGameObj = (gameObjHoveredOn && gameObjHoveredOn->getPlayer() == mainPlayer);
+			bool alliedGameObj = (gameObjHoveredOn && !ownGameObj && gameObjHoveredOn->getPlayer()->getTeam() == mainPlayer->getTeam());
 			bool gameObjUnit = (gameObjHoveredOn && gameObjHoveredOn->getType() == GameObject::Type::UNIT);
 			bool gameObjTransport = (gameObjUnit && ((Unit*)gameObjHoveredOn)->getNumGarrisonSlots() > 0);
 			bool canGarrison = true;
@@ -145,22 +147,64 @@ namespace battleship{
 						break;
 					}
 
-			bool supply = (
-					gameObjUnit && 
-					((Unit*)gameObjHoveredOn)->getUnitClass() == UnitClass::EXTRACTOR &&
-					mainPlayer->getSelectedUnit(0)->getUnitClass() == UnitClass::RESOURCE_ROVER
-			);
+			vector<TradeOffer*> offers = (gameObjHoveredOn && alliedGameObj ? mainPlayer->getTradeOffers(gameObjHoveredOn->getPlayer()) : vector<TradeOffer*>{});
+			bool tradeResource[NUM_RESOURCES][2], trade = false;
+
+			for(int i = 0; i < NUM_RESOURCES; i++)
+				for(int j = 0; j < 2; j++){
+					if(!offers.empty() && offers[0]->tradeResources[i][j] > 0){
+						tradeResource[i][j] = true;
+						trade = true;
+					}
+					else tradeResource[i][j] = false;
+				}
+
+			int objClass = (gameObjUnit ? int(((Unit*)gameObjHoveredOn)->getUnitClass()) : -1);
+			bool tradeCenter = ((UnitClass)objClass == UnitClass::TRADE_CENTER);
+			bool refinery = ((UnitClass)objClass == UnitClass::REFINERY);
+			bool lab = ((UnitClass)objClass == UnitClass::LAB);
+			bool ownExtractor = (ownGameObj && (UnitClass)objClass == UnitClass::EXTRACTOR);
+
+			bool roverSelected = (mainPlayer->getSelectedUnit(0)->getUnitClass() == UnitClass::RESOURCE_ROVER);
+			ResourceRover *rover = (roverSelected ? (ResourceRover*)mainPlayer->getSelectedUnit(0) : nullptr);
+			int unloadFlag = (int)shiftPressed;
 
 			if(!forceCursorState){
 				if(gameObjUnit && gameObjTransport){
 					orderPossible = (ownGameObj && canGarrison);
 					cursorState = CursorState::GARRISON;
 				}
-				else if(supply){
-					orderPossible = (ownGameObj && ((Extractor*)gameObjHoveredOn)->getDeposit()->getAmmount());
+				else if(roverSelected && ownExtractor){
+					orderPossible = (((Extractor*)gameObjHoveredOn)->getDeposit()->getAmmount() > 0);
 					cursorState = CursorState::SUPPLY;
 				}
-				else if(gameObjUnit && !ownGameObj)
+				else if(roverSelected && (tradeCenter || refinery || lab) && (ownGameObj || (alliedGameObj && trade))){
+					bool tradeRes = false;
+					int resId;
+					
+					switch((UnitClass)objClass){
+						case UnitClass::TRADE_CENTER:
+							tradeRes = tradeResource[(int)ResourceType::WEALTH][unloadFlag];
+							resId = (int)ResourceType::WEALTH;
+							break;
+						case UnitClass::REFINERY:
+							tradeRes = tradeResource[(int)ResourceType::REFINEDS][unloadFlag];
+							resId = (int)ResourceType::REFINEDS;
+							break;
+						case UnitClass::LAB:
+							tradeRes = tradeResource[(int)ResourceType::RESEARCH][unloadFlag];
+							resId = (int)ResourceType::RESEARCH;
+							break;
+					}
+					
+					bool canLoad = (rover && rover->calcTotalLoad() < rover->getCapacity());
+					orderPossible = (unloadFlag ? rover->getLoad(resId) > 0 : canLoad);
+
+					if(alliedGameObj) orderPossible = tradeRes && orderPossible;
+
+					cursorState = (unloadFlag ? CursorState::UNLOAD : CursorState::LOAD);
+				}
+				else if(gameObjUnit && !(ownGameObj || alliedGameObj))
 					cursorState = CursorState::ATTACK;
 				else
 					cursorState = CursorState::NORMAL;
@@ -169,7 +213,29 @@ namespace battleship{
 				if(cursorState == CursorState::GARRISON)
 					orderPossible = (ownGameObj && gameObjTransport && canGarrison);
 				else if(cursorState == CursorState::SUPPLY)
-					orderPossible = (ownGameObj && supply && ((Extractor*)gameObjHoveredOn)->getDeposit()->getAmmount());
+					orderPossible = (roverSelected && ownExtractor);
+				else if(cursorState == CursorState::LOAD || cursorState == CursorState::UNLOAD){
+					int ulf = int(cursorState == CursorState::UNLOAD);
+					bool tradeRefs = tradeResource[(int)ResourceType::REFINEDS][ulf];
+					bool tradeWealth = tradeResource[(int)ResourceType::WEALTH][ulf];
+					bool tradeTech = tradeResource[(int)ResourceType::RESEARCH][ulf];
+					
+					bool canLoad = (rover->calcTotalLoad() < rover->getCapacity());
+					bool loadResource = (
+							cursorState == CursorState::LOAD ? canLoad : (
+								rover->getLoad((int)ResourceType::REFINEDS) > 0 ||
+								rover->getLoad((int)ResourceType::WEALTH) > 0 ||
+								rover->getLoad((int)ResourceType::RESEARCH) > 0
+							)
+					);
+
+					bool transferResource = (
+						(refinery && loadResource && (ownGameObj || (alliedGameObj && tradeRefs))) ||
+						(tradeCenter && loadResource && (ownGameObj || (alliedGameObj && tradeWealth))) ||
+						(lab && loadResource && (ownGameObj || (alliedGameObj && tradeTech)))
+					);
+					orderPossible = (roverSelected && transferResource);
+				}
 				else if(cursorState == CursorState::HACK)
 					orderPossible = (!ownGameObj && gameObjUnit && mainPlayer->getSelectedUnit(0)->getUnitClass() == UnitClass::ENGINEER);
 				else if(gameObjUnit)
@@ -190,6 +256,8 @@ namespace battleship{
 				tex = (orderPossible ? garrisonTex : noGarrisonTex);
 				break;
 			case CursorState::SUPPLY:
+			case CursorState::LOAD:
+			case CursorState::UNLOAD:
 				tex = (orderPossible ? supplyTex : noSupplyTex);
 				break;
 			case CursorState::HACK:
@@ -243,6 +311,12 @@ namespace battleship{
 			fc->removeGameObjectFrames();
 		}
 
+		if(!tradingScreen){
+			guiTexts = guiManager->getTexts();
+			guiRects = guiManager->getGuiRectangles();
+			guiButtons = guiManager->getButtons();
+		}
+
         renderUnits();
 
 		vector<Unit*> currSelectedUnits = mainPlayer->getSelectedUnits();
@@ -486,6 +560,7 @@ namespace battleship{
     }
 
 	//TODO fix ejectable unit selection with multiple transports selected
+	//TODO replace shiftPressed with a dedicated buy flag
     void ActiveGameState::issueOrder(Order::TYPE type, vector<Order::Target> targets, bool addOrder) {
 		depth = 1;
 		Vector3 destDir =  Vector3::VEC_ZERO;
@@ -540,11 +615,9 @@ namespace battleship{
 	}
     
     void ActiveGameState::onAction(int bind, bool isPressed) {
+		if(tradingScreen || !ConcreteGuiManager::getSingleton()->findClickedButtons().empty()) return;
+
 		GameObjectFrameController *ufCtr = GameObjectFrameController::getSingleton();
-
-		if(!ConcreteGuiManager::getSingleton()->findClickedButtons().empty())
-			return;
-
 		vector<Unit*> selectedUnits = mainPlayer->getSelectedUnits();
 
         switch((Bind)bind){
@@ -612,6 +685,12 @@ namespace battleship{
 						else if(cursorState == CursorState::SUPPLY){
 							if(orderPossible) issueOrder(Order::TYPE::SUPPLY, vector<Order::Target>{Order::Target((Unit*)gameObjHoveredOn)}, shiftPressed);
 						}
+						else if(cursorState == CursorState::LOAD){
+							if(orderPossible) issueOrder(Order::TYPE::LOAD, vector<Order::Target>{Order::Target((Unit*)gameObjHoveredOn)}, shiftPressed);
+						}
+						else if(cursorState == CursorState::UNLOAD){
+							if(orderPossible) issueOrder(Order::TYPE::UNLOAD, vector<Order::Target>{Order::Target((Unit*)gameObjHoveredOn)}, shiftPressed);
+						}
 						else if(cursorState == CursorState::ATTACK){
 							if(controlPressed && !gameObjHoveredOn){
                     			castRayToTerrain();

activeGameState.h

@@ -29,6 +29,8 @@ namespace battleship{
 			ATTACK,
 			GARRISON,
 			SUPPLY,
+			LOAD,
+			UNLOAD,
 			HACK
 		};
 
@@ -42,8 +44,10 @@ namespace battleship{
 		void onRawMouseWheelScroll(bool);
 		inline CursorState getCursorState(){return cursorState;}
 		inline void setCursorState(CursorState cs){this->cursorState = cs;}
-		inline void addButton(vb01Gui::Button *b){buttons.push_back(b);}
-		inline std::vector<vb01Gui::Button*> getButtons(){return buttons;}
+		inline void addButton(vb01Gui::Button *b){guiButtons.push_back(b);}
+		inline std::vector<vb01Gui::Button*> getGuiButtons(){return guiButtons;}
+		inline std::vector<vb01::Node*> getGuiRects(){return guiRects;}
+		inline std::vector<vb01::Text*> getGuiTexts(){return guiTexts;}
         inline Player* getPlayer(){return mainPlayer;}
         inline std::vector<Unit*>& getUnitGroup(int i){return unitGroups[i];}
 		inline void setBuildableStructSelected(bool bss){this->buildableStructSelected = bss;}
@@ -51,6 +55,10 @@ namespace battleship{
 		inline float getDepth(){return depth;}
 		inline void setForceCursorState(bool force){this->forceCursorState = force;}
 		inline bool isForceCursorState(){return forceCursorState;}
+		inline void setTradingScreen(bool ts){this->tradingScreen = ts;}
+		inline bool isTradingScreen(){return tradingScreen;}
+		inline void setOfferScreen(bool os){this->offerScreen = os;}
+		inline bool isOfferScreen(){return offerScreen;}
     private:
 		bool selectedUnitsAmongst(std::vector<Unit*>);
 		void updateGameObjHoveredOn();
@@ -75,11 +83,13 @@ namespace battleship{
         GuiAppState *guiState;
 		std::string unitGuiScreen = "";
 		GameObject *gameObjHoveredOn = nullptr;
-		vb01::Node *dragboxNode = nullptr;
 		vb01::Vector2 clickPoint;
         std::vector<Unit*> unitGroups[9], prevSelectedUnits;
 		std::vector<Order::Target> targets;
-		std::vector<vb01Gui::Button*> buttons, unitButtons;
+		vb01::Node *dragboxNode = nullptr;
+		std::vector<vb01::Node*> guiRects;
+		std::vector<vb01::Text*> guiTexts;
+		std::vector<vb01Gui::Button*> guiButtons, unitButtons;
         bool isSelectionBox = false;
 		bool shiftPressed = false;
 		bool controlPressed = false;
@@ -90,6 +100,8 @@ namespace battleship{
 		bool selectingDestOrient = false;
 		bool forceCursorState = false;
 		bool orderPossible = false;
+		bool tradingScreen = false;
+		bool offerScreen = false;
         int playerId, zooms = 0;
 	   	const int NUM_MAX_ZOOMS = 10;
 		float depth = 1;

activeStateBackButton.cpp

@@ -0,0 +1,21 @@
+#include "activeStateBackButton.h"
+#include "activeGameState.h"
+#include "gameManager.h"
+
+#include <stateManager.h>
+
+namespace battleship{
+	using namespace std;
+	using namespace vb01;
+	using namespace gameBase;
+
+	ActiveStateBackButton::ActiveStateBackButton(Vector3 pos, Vector2 size, string name) : BackButton(pos, size, name, "activeGameState.lua"){}
+
+	void ActiveStateBackButton::onClick(){
+		StateManager *stateManager = GameManager::getSingleton()->getStateManager();
+		ActiveGameState *activeState = (ActiveGameState*)stateManager->getAppStateByType((int)AppStateType::ACTIVE_STATE);
+		activeState->setTradingScreen(false);
+
+		BackButton::onClick();
+	}
+}

activeStateBackButton.h

@@ -0,0 +1,15 @@
+#ifndef ACTIVE_STATE_BACK_BUTTON_H
+#define ACTIVE_STATE_BACK_BUTTON_H
+
+#include "backButton.h"
+
+namespace battleship{
+	class ActiveStateBackButton : public BackButton{
+		public:
+			ActiveStateBackButton(vb01::Vector3, vb01::Vector2, std::string);
+			void onClick();
+		private:
+	};
+}
+
+#endif

activeStateButton.cpp

@@ -18,15 +18,28 @@ namespace battleship{
 	using namespace vb01Gui;
 	using namespace gameBase;
 
-	ActiveStateButton::ActiveStateButton(Vector3 pos, Vector2 size, string gs, string name, string fontPath, int trigger, string imagePath) : Button(pos, size, name, fontPath, trigger, true, imagePath), guiScreen(gs){
+	ActiveStateButton::ActiveStateButton(Vector3 pos, Vector2 size, string gs, string name, string fontPath, int trigger, string imagePath) : 
+		Button(pos, size, name, fontPath, trigger, true, imagePath), guiScreen(gs){}
+
+	void ActiveStateButton::onClick(){
 		StateManager *stateManager = GameManager::getSingleton()->getStateManager();
 		ActiveGameState *activeState = (ActiveGameState*)stateManager->getAppStateByType((int)AppStateType::ACTIVE_STATE);
 
-		if(activeState)
-			activeState->addButton(this);
-	}
+		vector<Button*> buttons = activeState->getGuiButtons();
+		buttons.push_back(this);
 
-	void ActiveStateButton::onClick(){
-		ConcreteGuiManager::getSingleton()->parseLuaScript(guiScreen);
+		vector<Node*> rects = activeState->getGuiRects();
+		vector<Text*> texts = activeState->getGuiTexts();
+
+		ConcreteGuiManager::getSingleton()->readLuaScreenScript(
+			guiScreen,
+			buttons,
+			vector<Listbox*>{},
+			vector<Checkbox*>{},
+			vector<Slider*>{},
+			vector<Textbox*>{},
+			rects,
+			texts
+		);
 	}
 }

backButton.cpp

@@ -7,20 +7,11 @@ namespace battleship{
 	using namespace vb01;
 	using namespace vb01Gui;
 
-    BackButton::BackButton(Vector3 pos, Vector2 size, string name, string screen) : Button(pos, size, name, GameManager::getSingleton()->getPath() + "Fonts/batang.ttf", -1, true) {
-		this->screen = screen;
-	}
+    BackButton::BackButton(Vector3 pos, Vector2 size, string name, string scr) :
+		Button(pos, size, name, GameManager::getSingleton()->getPath() + "Fonts/batang.ttf", -1, true),
+		screen(scr){}
 
     void BackButton::onClick() {
-		ConcreteGuiManager *guiManager = ConcreteGuiManager::getSingleton();
-		guiManager->removeAllButtons(vector<Button*>{this});
-		guiManager->removeAllListboxes();
-		guiManager->removeAllCheckboxes();
-		guiManager->removeAllSliders();
-		guiManager->removeAllTextboxes();
-
-		guiManager->readLuaScreenScript(screen);
-
-		guiManager->removeButton(this);
+		ConcreteGuiManager::getSingleton()->readLuaScreenScript(screen);
 	}
 }

concreteGuiManager.cpp

@@ -36,6 +36,7 @@
 #include "orderButton.h"
 #include "stateToggleButton.h"
 #include "minimapButton.h"
+#include "activeStateBackButton.h"
 
 namespace battleship{
 	using namespace std;
@@ -207,9 +208,8 @@ namespace battleship{
 			case SELL_RESEARCH:
 				button = new TradeButton(pos, size, name, (int)guiTable["trigger"], imagePath, (int)SOL_LUA_STATE["UnitId"]["TRADE_CENTER"], TradeButton::Type::SELL_RESEARCH);
 				break;
-			case ACTIVE_GAME_STATE:
-				guiScreen = guiTable["guiScreen"];
-				button = new ActiveStateButton(pos, size, guiScreen, name, fontBasePath + "batang.ttf", (int)guiTable["trigger"], imagePath);
+			case ACTIVE_STATE_BACK:
+				button = new ActiveStateBackButton(pos, size, name);
 				break;
 			case PLAYER_TRADE:
 				guiScreen = guiTable["guiScreen"];
@@ -534,7 +534,6 @@ namespace battleship{
 			vector<Text*> textExceptions
 		){
 		removeAllGuiElements(buttonExceptions, listboxExceptions, checkboxExceptions, sliderExceptions, textboxExceptions, guiRectboxExceptions, textExceptions);
-		guiElements.clear();
 		parseLuaScript(script);
 	}
 
@@ -556,11 +555,12 @@ namespace battleship{
 		for(Node *r : guiRectboxs) removeGuiRectangle(r);
 		for(Text *t : texts) removeText(t);
 
-		guiElements.clear();
 		parseLuaScript(script);
 	}
 
 	void ConcreteGuiManager::parseLuaScript(string script){
+		guiElements.clear();
+
 		string basePath = GameManager::getSingleton()->getPath() + "Scripts/Gui/";
 		sol::state_view SOL_LUA_VIEW = generateView();
 		SOL_LUA_VIEW.script_file(basePath + script);

concreteGuiManager.h

@@ -45,14 +45,14 @@ namespace battleship{
 		SELL_REFINEDS,
 		BUY_RESEARCH,
 		SELL_RESEARCH,
-		ACTIVE_GAME_STATE,
+		ACTIVE_STATE_BACK,
 		PLAYER_TRADE,
 		TRADING_SCREEN,
 		TRADE_OFFER,
 		RESOURCE_AMMOUNT,
 		UNIT_STATE,
 		ORDER,
-		MINIMAP
+		MINIMAP,
 	};
 	enum ListboxType {
 		CONTROLS,

game.cpp

@@ -101,13 +101,13 @@ namespace battleship{
 
         if (!paused) {
             gm->getStateManager()->dettachAppState(activeState);
-			guiManager->readLuaScreenScript("gamePaused.lua", activeState->getButtons());
+			guiManager->readLuaScreenScript("gamePaused.lua", activeState->getGuiButtons());
         } 
         else {
 			for(string f : configData::scripts)
 				generateView().script_file(gm->getPath() + f);
 
-			guiManager->readLuaScreenScript("inGame.lua", activeState->getButtons());
+			guiManager->readLuaScreenScript("inGame.lua", activeState->getGuiButtons());
 			sol::state_view SOL_LUA_VIEW = generateView();
 			string gop = SOL_LUA_VIEW["gameObjPrefix"], vfxp = SOL_LUA_VIEW["vfxPrefix"];
 			AssetManager::getSingleton()->load(gm->getPath() + gop, true);
@@ -276,14 +276,4 @@ namespace battleship{
 
 		return false;
 	}
-
-	vector<TradeOffer*> Game::findTradeOffers(Player *pl1, Player *pl2){
-		vector<TradeOffer*> offers;
-
-		for(TradeOffer *to : tradeOffers)
-			if((to->initPlayer == pl1 || to->recPlayer == pl1) && (to->initPlayer == pl2 || to->recPlayer == pl2))
-				offers.push_back(to);
-
-		return offers;
-	}
 }

game.h

@@ -27,9 +27,7 @@ namespace battleship{
 			void initTechnologies();
 			float calcAbilFromTech(Ability::Type, std::vector<int>, int, int);
 			bool isUnitUnlocked(std::vector<int>, int);
-			std::vector<TradeOffer*> findTradeOffers(Player*, Player*);
 			inline void setDebug(bool d){this->debug = d;}
-			inline void addTradeOffer(TradeOffer *to){tradeOffers.push_back(to);}
 			inline void addPlayer(Player *pl){players.push_back(pl);}
 			inline bool isDebug(){return debug;}
 			inline std::vector<Player*>& getPlayers(){return players;}
@@ -46,7 +44,6 @@ namespace battleship{
 			std::vector<Technology> technologies;
 			std::vector<Ability> abilities;
 			std::vector<Player*> players;
-			std::vector<TradeOffer*> tradeOffers;
 	};
 }
 

offerButton.cpp

@@ -16,24 +16,25 @@ namespace battleship{
 	using namespace vb01Gui;
 	using namespace gameBase;
 
-	OfferButton::OfferButton(Vector3 pos, Vector2 size, int plId, string name, int trigger, string imagePath) : Button(pos, size, name, GameManager::getSingleton()->getPath() + "Fonts/batang.ttf", trigger, true, imagePath), playerId(plId){}
+	OfferButton::OfferButton(Vector3 pos, Vector2 size, int plId, string name, int trigger, string imagePath) : 
+		Button(pos, size, name, GameManager::getSingleton()->getPath() + "Fonts/batang.ttf", trigger, true, imagePath),
+		playerId(plId){}
 
 	void OfferButton::onClick(){
 		ConcreteGuiManager *guiManager = ConcreteGuiManager::getSingleton();
 		vector<Textbox*> textboxes = guiManager->getTextboxes();
 
-		int recRef = (textboxes[0]->getText() == L"" ? 0 : stoi(textboxes[0]->getText())); 
-		int initRef = (textboxes[1]->getText() == L"" ? 0 : stoi(textboxes[1]->getText())); 
-		int recWealth = (textboxes[2]->getText() == L"" ? 0 : stoi(textboxes[2]->getText())); 
-		int initWealth = (textboxes[3]->getText() == L"" ? 0 : stoi(textboxes[3]->getText()));
-		int recRes = (textboxes[4]->getText() == L"" ? 0 : stoi(textboxes[4]->getText()));
-		int initRes = (textboxes[5]->getText() == L"" ? 0 : stoi(textboxes[5]->getText())); 
+		int buyRef = (textboxes[0]->getText() == L"" ? 0 : stoi(textboxes[0]->getText())); 
+		int sellRef = (textboxes[1]->getText() == L"" ? 0 : stoi(textboxes[1]->getText())); 
+		int buyWealth = (textboxes[2]->getText() == L"" ? 0 : stoi(textboxes[2]->getText())); 
+		int sellWealth = (textboxes[3]->getText() == L"" ? 0 : stoi(textboxes[3]->getText()));
+		int buyRes = (textboxes[4]->getText() == L"" ? 0 : stoi(textboxes[4]->getText()));
+		int sellRes = (textboxes[5]->getText() == L"" ? 0 : stoi(textboxes[5]->getText())); 
 
 		StateManager *stateManager = GameManager::getSingleton()->getStateManager();
 		ActiveGameState *activeState = (ActiveGameState*)stateManager->getAppStateByType((int)AppStateType::ACTIVE_STATE);
 		Player *mainPlayer = activeState->getPlayer();
 
-		Game *game = Game::getSingleton();
-		game->addTradeOffer(new TradeOffer(mainPlayer, game->getPlayer(playerId), initRef, recRef, initWealth, recWealth, initRes, recRes));
+		mainPlayer->addTradeOffer(Game::getSingleton()->getPlayer(playerId), new TradeOffer(buyRef, sellRef, buyWealth, sellWealth, buyRes, sellRes));
 	}
 }

orderButton.cpp

@@ -45,6 +45,12 @@ namespace battleship{
 						case Order::TYPE::SUPPLY:
 							cs = ActiveGameState::CursorState::SUPPLY;
 							break;
+						case Order::TYPE::LOAD:
+							cs = ActiveGameState::CursorState::LOAD;
+							break;
+						case Order::TYPE::UNLOAD:
+							cs = ActiveGameState::CursorState::UNLOAD;
+							break;
 						case Order::TYPE::HACK:
 							cs = ActiveGameState::CursorState::HACK;
 							break;

player.cpp

@@ -1,9 +1,11 @@
 #include <solUtil.h>
+#include <stateManager.h>
 
 #include "player.h"
+#include "game.h"
 #include "structure.h"
 #include "projectile.h"
-#include "stateManager.h"
+#include "tradeOffer.h"
 #include "activeGameState.h"
 #include "resourceDeposit.h"
 
@@ -20,9 +22,10 @@ namespace battleship{
 		cpuPlayer(cpuPl), 
 		spawnPointId(sp), 
 		name("pl"), 
-		refineds(30000), 
 		trader(new Trader())
 	{
+		resources[0] = 30000;
+
 		colorMaterial = new Material(Root::getSingleton()->getLibPath() + "texture");
 		colorMaterial->addBoolUniform("lightingEnabled", true);
 		colorMaterial->addBoolUniform("texturingEnabled", false);
@@ -38,22 +41,33 @@ namespace battleship{
 
 		vector<Unit*> units = this->units; 
 		for(Unit *u : units){
-			if(!u->isRemove())
-				u->update();
-			else
-				removeUnit(u);
+			if(!u->isRemove()) u->update();
+			else removeUnit(u);
 		}
 
 		vector<Projectile*> projectiles = this->projectiles; 
 		for(Projectile *proj : projectiles){
-			if(!proj->isRemove())
-				proj->update();
-			else
-				removeProjectile(proj);
+			if(!proj->isRemove()) proj->update();
+			else removeProjectile(proj);
 		}
 
-		for(ResourceDeposit *rd : resourceDeposits)
-			rd->update();
+		for(ResourceDeposit *rd : resourceDeposits) rd->update();
+		
+		for(pair<Player*, vector<TradeOffer*>> &pair : tradeOffers){
+			if(pair.second.empty()) continue;
+
+			bool fulfiled = true;
+
+			for(int i = 0; i < NUM_RESOURCES && fulfiled; i++){
+				bool b = (pair.second[0]->tradeResources[i][0] == pair.second[0]->deliveredResources[i][0]);
+				bool s = (pair.second[0]->tradeResources[i][1] == pair.second[0]->deliveredResources[i][1]);
+
+				if(!(b && s)) fulfiled = false;
+			}
+
+			if(fulfiled)
+				pair.second.erase(pair.second.begin());
+		}
     }
 
 	int Player::getOrderLineId(Order::TYPE type, Vector3 startPos, Vector3 endPos){
@@ -73,6 +87,8 @@ namespace battleship{
 				break;
       	    case Order::TYPE::BUILD:
       	    case Order::TYPE::SUPPLY:
+      	    case Order::TYPE::LOAD:
+      	    case Order::TYPE::UNLOAD:
 				color = Vector3(1, 1, 0);
       	        break;
       	    case Order::TYPE::HACK:
@@ -184,40 +200,48 @@ namespace battleship{
 		return ucUnits;
 	}
 
-	void Player::addTechnology(int techId){
-		technologies.push_back(techId);
-	}
+	void Player::updateTradedResource(Player *player, ResourceType type, int amount, bool selfDistributed, bool increased){
+		for(pair<Player*, vector<TradedResource>> pair : tradedResources)
+			if(pair.first == player){
+				TradedResource &tr = pair.second[(int)type];
 
-	int Player::getResource(ResourceType type){
-		switch(type){
-			case ResourceType::REFINEDS:
-				return refineds;
-			case ResourceType::WEALTH:
-				return wealth;
-			case ResourceType::RESEARCH:
-				return research;
+				if(selfDistributed) (increased ? tr.taken : tr.given) += amount;
+				else (increased ? tr.received : tr.hadTaken) += amount;
+
+				break;
+			}
+	} 
+
+	void Player::initTradingVecs(){
+		vector<Player*> players = Game::getSingleton()->getPlayers();
+
+		for(Player *pl : players){
+			if(this == pl) continue;
+
+			if(team == pl->getTeam()){
+				tradeOffers.push_back(make_pair(pl, vector<TradeOffer*>{}));
+				tradedResources.push_back(make_pair(pl, vector<TradedResource>{
+							TradedResource(ResourceType::REFINEDS), 
+							TradedResource(ResourceType::WEALTH), 
+							TradedResource(ResourceType::RESEARCH)
+				}));
+			}
 		}
 	}
 
-	void Player::updateResource(ResourceType type, int ammount, bool add){
-		switch(type){
-			case ResourceType::REFINEDS:
-				refineds = (add ? refineds + ammount : ammount);
-				break;
-			case ResourceType::WEALTH:
-				wealth = (add ? wealth + ammount : ammount);
-				break;
-			case ResourceType::RESEARCH:
-				research = (add ? research + ammount : ammount);
-				break;
-		}
+	void Player::addTradeOffer(Player *player, TradeOffer *offer){
+		if(tradeOffers.empty()) initTradingVecs();
+
+		for(pair<Player*, vector<TradeOffer*>> &offers : tradeOffers)
+			if(offers.first == player)
+				offers.second.push_back(offer);
 	}
 
-	void Player::build(int id, Vector3 pos, Quaternion rot, bool additionalOrder){
-		/*
-		Unit *buildStruct = GameObjectFactory::createUnit(this, id, pos, rot);
-		addUnit(buildStruct);
-		issueOrder(Order::TYPE::BUILD, vector<Order::Target>{Order::Target(buildStruct)}, additionalOrder);
-		*/
+	vector<TradeOffer*> Player::getTradeOffers(Player *player){
+		for(pair<Player*, vector<TradeOffer*>> offers : tradeOffers)
+			if(offers.first == player)
+				return offers.second;
+
+		return vector<TradeOffer*>{};
 	}
 }

player.h

@@ -2,6 +2,7 @@
 #define PLAYER_H
 
 #include <vector>
+#include <algorithm>
 
 #include "gameManager.h"
 #include "trader.h"
@@ -11,7 +12,9 @@ namespace battleship{
 	class ResourceDeposit;
 	class Projectile;
 	class Unit;
+	struct TradeOffer;
 
+	const int NUM_RESOURCES = 3;
 	enum class ResourceType{REFINEDS, WEALTH, RESEARCH};
 
     class Player {
@@ -29,10 +32,12 @@ namespace battleship{
 		void selectUnits(std::vector<Unit*>);
 		std::vector<Unit*> getUnitsById(int, int = -1);
 		std::vector<Unit*> getUnitsByClass(UnitClass, int = -1);
-		void addTechnology(int);
-		int getResource(ResourceType);
-		void updateResource(ResourceType, int, bool);
-		void build(int, vb01::Vector3, vb01::Quaternion, bool);
+		void addTechnology(int id){technologies.push_back(id);}
+		void updateTradedResource(Player*, ResourceType, int, bool, bool);
+		void addTradeOffer(Player*, TradeOffer*);
+		std::vector<TradeOffer*> getTradeOffers(Player*);
+		inline int getResource(ResourceType rt){return resources[(int)rt];}
+		inline void updateResource(ResourceType rt, int amount, bool add){resources[(int)rt] = (add ? resources[(int)rt] + amount : amount);}
 		inline Trader* getTrader(){return trader;}
 		inline void deselectUnits(){selectedUnits.clear();}
 		inline Unit* getSelectedUnit(int id){return selectedUnits[id];}
@@ -72,10 +77,17 @@ namespace battleship{
 		inline vb01::Material* getColorMaterial(){return colorMaterial;}
 		inline std::vector<int> getTechnologies(){return technologies;}
     private:
+		struct TradedResource{
+			ResourceType type;
+			int taken = 0, given = 0, received = 0, hadTaken = 0;
+
+			TradedResource(ResourceType t) : type(t){}
+		};
+
 		bool cpuPlayer = false;
 		std::vector<int> technologies;
 		int luaPlayerId;
-        int refineds = 0, wealth = 0, research = 0;
+        int resources[3]{0, 0, 0};
 		int faction, difficulty, team;
 		int vehiclesBuilt = 0, vehiclesDestroyed = 0, vehiclesLost = 0;
 		int structuresBuilt = 0, structuresDestroyed = 0, structuresLost = 0;
@@ -87,8 +99,11 @@ namespace battleship{
 		std::vector<ResourceDeposit*> resourceDeposits;
         vb01::Vector3 color;
 		vb01::Material *colorMaterial = nullptr;
+		std::vector<std::pair<Player*, std::vector<TradeOffer*>>> tradeOffers;
+		std::vector<std::pair<Player*, std::vector<TradedResource>>> tradedResources;
 
 		int getOrderLineId(Order::TYPE, vb01::Vector3, vb01::Vector3);
+		void initTradingVecs();
     };
 }
 

playerTradeButton.cpp

@@ -16,10 +16,15 @@ namespace battleship{
 	PlayerTradeButton::PlayerTradeButton(Vector3 pos, Vector2 size, string gs, string name, int trigger, string imagePath) : ActiveStateButton(pos, size, gs, name, GameManager::getSingleton()->getPath() + "Fonts/batang.ttf", trigger, imagePath){}
 
 	void PlayerTradeButton::onClick(){
-		ActiveStateButton::onClick();
-
 		StateManager *stateManager = GameManager::getSingleton()->getStateManager();
 		ActiveGameState *activeState = (ActiveGameState*)stateManager->getAppStateByType((int)AppStateType::ACTIVE_STATE);
+
+		if(activeState->isTradingScreen() && !activeState->isOfferScreen()) return;
+		else if(!activeState->isTradingScreen()) activeState->setTradingScreen(true);
+		else if(activeState->isOfferScreen()) activeState->setOfferScreen(false);
+
+		ActiveStateButton::onClick();
+
 		Player *mainPlayer = activeState->getPlayer();
 		Game *game = Game::getSingleton();
 
@@ -28,40 +33,33 @@ namespace battleship{
 		sol::state_view SOL_LUA_VIEW = generateView();
 
 		for(int i = 0, lineId = 0; i < players.size(); i++){
-			if(players[i] != mainPlayer){
-				vector<Button*> buttons = guiManager->getButtons(); 
-				vector<Listbox*> listboxes = guiManager->getListboxes(); 
-				vector<Checkbox*> checkboxes = guiManager->getCheckboxes(); 
-				vector<Slider*> sliders = guiManager->getSliders(); 
-				vector<Textbox*> textboxes = guiManager->getTextboxes(); 
-				vector<Node*> guiRects = guiManager->getGuiRectangles(); 
-				vector<Text*> texts = guiManager->getTexts(); 
+			if(players[i] == mainPlayer) continue;
 
-				SOL_LUA_VIEW.script("lineId = " + to_string(lineId));
-				SOL_LUA_VIEW.script("playerId = " + to_string(i));
-				guiManager->readLuaScreenScript("tradingPlayerGuiTray.lua", buttons, listboxes, checkboxes, sliders, textboxes, guiRects, texts);
+			SOL_LUA_VIEW.script("lineId = " + to_string(lineId));
+			SOL_LUA_VIEW.script("playerId = " + to_string(i));
+			SOL_LUA_VIEW.script(string("relationsIcon = ") + (players[i]->getTeam() == mainPlayer->getTeam() ? "allianceIcon" : "warIcon"));
+			guiManager->parseLuaScript("tradingPlayerGuiTray.lua");
 
-				vector<Button*> guiButtons = guiManager->getButtons();
+			vector<Button*> guiButtons = guiManager->getButtons();
 
-				for(int j = guiButtons.size() - 1; j > 0; j--)
-					if(guiButtons[j]->getName() == "Offer")
-						((OfferButton*)guiButtons[j])->setPlayerId(i);
+			for(int j = guiButtons.size() - 1; j > 0; j--)
+				if(guiButtons[j]->getName() == "Offer")
+					((OfferButton*)guiButtons[j])->setPlayerId(i);
 
-				int numListboxes = guiManager->getListboxes().size();
-				Listbox *listbox = guiManager->getListboxes()[numListboxes - 1];
-				int numOffers = game->findTradeOffers(mainPlayer, players[i]).size();
+			int numListboxes = guiManager->getListboxes().size();
+			Listbox *listbox = guiManager->getListboxes()[numListboxes - 1];
+			int numOffers = mainPlayer->getTradeOffers(players[i]).size();
 
-				for(int j = 0; j < numOffers; j++)
-					listbox->addLine(L"TRADE_OFFER_" + to_wstring(j));
+			for(int j = 0; j < numOffers; j++)
+				listbox->addLine(L"TRADE_OFFER_" + to_wstring(j));
 
-				if(listbox->getNumLines() < listbox->getMaxDisplay())
-					listbox->setMaxDisplay(listbox->getNumLines());
+			if(listbox->getNumLines() < listbox->getMaxDisplay())
+				listbox->setMaxDisplay(listbox->getNumLines());
 
-				int numTexts = guiManager->getTexts().size();
-				guiManager->getTexts()[numTexts - 1]->setText(stringToWstring(players[i]->getName()));
+			int numTexts = guiManager->getTexts().size();
+			guiManager->getTexts()[numTexts - 1]->setText(stringToWstring(players[i]->getName()));
 
-				lineId++;
-			}
+			lineId++;
 		}
 	}
 }

researchStruct.cpp

@@ -40,7 +40,7 @@ namespace battleship{
 		if(researchQueue.empty()){
 			if(health > .3 * maxHealth && player->getResource(ResourceType::REFINEDS) >= researchCost && canUpdateResearch()){
 				player->updateResource(ResourceType::RESEARCH, generationSpeed, true);
-				player->updateResource(ResourceType::REFINEDS, researchCost, true);
+				player->updateResource(ResourceType::REFINEDS, -researchCost, true);
 				lastUpdateTime = getTime();
 			}
 

resourceRover.cpp

@@ -18,6 +18,8 @@ namespace battleship{
 		Vector2 size = Vector2(lenHpBar, 10);
 		loadBackground = Unit::createBar(Vector2::VEC_ZERO, size,  Vector4(0, 0, 0, 1));
 		loadForeground = Unit::createBar(Vector2::VEC_ZERO, size,  Vector4(1, 1, 0, 1));
+
+		initProperties();
 	}
 
 	ResourceRover::~ResourceRover(){
@@ -26,7 +28,6 @@ namespace battleship{
 	}
 
 	void ResourceRover::initProperties(){
-		Vehicle::initProperties();
 		Game *game = Game::getSingleton();
 		vector<int> currTechs = player->getTechnologies();
 
@@ -36,55 +37,118 @@ namespace battleship{
 		loadRate = unitTable["loadRate"]; loadRate += game->calcAbilFromTech(Ability::Type::LOAD_RATE, currTechs, (int)GameObject::type, id);
 	}
 
-	void ResourceRover::supply(Order order){
-		float minDist = .5 * Map::getSingleton()->getCellSize().x;
+	void ResourceRover::loadResources(Structure *targStruct, float minDist, bool loadResource){
+		bool closeEnough = (pos.getDistanceFrom(targStruct->getPos()) <= minDist);
+		if(!closeEnough) return;
 
-		if(!pathPoints.empty())
-			navigate(minDist);
-		else{
-			vector<Unit*> units = player->getUnits();
-			vector<Structure*> extractors, refineries;
+		ResourceType resType;
 
-			for(Unit *unit : units){
-				if(unit->getUnitClass() == UnitClass::EXTRACTOR && ((Extractor*)unit)->getDeposit()->getAmmount() > 0)
-					extractors.push_back((Structure*)unit);
-				else if(unit->getUnitClass() == UnitClass::REFINERY)
-					refineries.push_back((Structure*)unit);
+		switch(targStruct->getUnitClass()){
+			case UnitClass::TRADE_CENTER:
+				resType = ResourceType::WEALTH;
+				break;
+			case UnitClass::REFINERY:
+				resType = ResourceType::REFINEDS;
+				break;
+			case UnitClass::LAB:
+				resType = ResourceType::RESEARCH;
+				break;
+		}
+
+		if(player == targStruct->getPlayer()){
+			if(!loadResource && canUnload((int)resType)){
+				player->updateResource(resType, loadSpeed, true);
+				cargo[(int)resType] -= loadSpeed;
+				lastLoadTime = getTime();
 			}
-
-			nearestExtractor = (Extractor*)getClosestUnit(extractors);
-			nearestRefinery = getClosestUnit(refineries);
-
-			if(nearestExtractor && nearestExtractor->getPos().getDistanceFrom(pos) <= minDist){
-				ResourceDeposit *deposit = nearestExtractor->getDeposit();
-
-				if(canLoad() && deposit->getAmmount() > 0){
-					if(nearestExtractor->canDraw()){
-						nearestExtractor->draw();
-						load += loadSpeed;
-						lastLoadTime = getTime();
-					}
-				}
-				else if(load == capacity && nearestRefinery)
-					preparePathpoints(order, nearestRefinery->getPos(), true);
-			}
-			else if(!nearestExtractor){
-				if(nearestRefinery && load > 0)
-					preparePathpoints(order, nearestRefinery->getPos(), true);
-				else
-					removeOrder(0);
-			}
-
-			if(nearestRefinery && nearestRefinery->getPos().getDistanceFrom(pos) <= minDist){
-				if(canUnload()){
-					load -= loadSpeed;
-					player->updateResource(ResourceType::REFINEDS, 1, true);
-					lastLoadTime = getTime();
-				}
-				else if(load == 0 && nearestExtractor)
-					preparePathpoints(order, nearestExtractor->getPos());
+			else if(loadResource && canLoad() && player->getResource(resType) > 0){
+				player->updateResource(resType, -loadSpeed, true);
+				cargo[(int)resType] += loadSpeed;
+				lastLoadTime = getTime();
 			}
 		}
+		else{
+			vector<TradeOffer*> offers = player->getTradeOffers(targStruct->getPlayer());
+			if(offers.empty()) return;
+
+			TradeOffer *offer = offers[0];
+
+			if(!loadResource && offer->tradeResources[(int)resType][1] > offer->deliveredResources[(int)resType][1] && canUnload((int)resType)){
+				targStruct->getPlayer()->updateResource(resType, loadSpeed, true);
+				offer->deliveredResources[(int)resType][1]++;
+				cargo[(int)resType] -= loadSpeed;
+				lastLoadTime = getTime();
+			}
+			else if(
+					loadResource &&
+					offer->tradeResources[(int)resType][0] > offer->deliveredResources[(int)resType][0] &&
+					targStruct->getPlayer()->getResource(resType) > 0 &&
+					canLoad()
+				)
+			{
+				targStruct->getPlayer()->updateResource(resType, -loadSpeed, true);
+				offer->deliveredResources[(int)resType][0]++;
+				cargo[(int)resType] += loadSpeed;
+				lastLoadTime = getTime();
+			}
+		}
+	}
+
+	//TODO equate rover load and extractor draw rates
+	void ResourceRover::collectRefineds(Order order, float minDist){
+		vector<Unit*> units = player->getUnits();
+		vector<Structure*> extractors, refineries;
+
+		for(Unit *unit : units){
+			if(unit->getUnitClass() == UnitClass::EXTRACTOR && ((Extractor*)unit)->getDeposit()->getAmmount() > 0)
+				extractors.push_back((Structure*)unit);
+			else if(unit->getUnitClass() == UnitClass::REFINERY)
+				refineries.push_back((Structure*)unit);
+		}
+
+		nearestExtractor = (Extractor*)getClosestUnit(extractors);
+		nearestRefinery = getClosestUnit(refineries);
+
+		if(nearestExtractor && nearestExtractor->getPos().getDistanceFrom(pos) <= minDist){
+			ResourceDeposit *deposit = nearestExtractor->getDeposit();
+
+			if(canLoad() && deposit->getAmmount() > 0){
+				if(nearestExtractor->canDraw()){
+					nearestExtractor->draw();
+					cargo[(int)ResourceType::REFINEDS] += loadSpeed;
+					lastLoadTime = getTime();
+				}
+			}
+			else if(calcTotalLoad() == capacity && nearestRefinery)
+				preparePathpoints(order, nearestRefinery->getPos(), true);
+		}
+		else if(!nearestExtractor){
+			if(nearestRefinery && cargo[(int)ResourceType::REFINEDS] > 0)
+				preparePathpoints(order, nearestRefinery->getPos(), true);
+			else
+				removeOrder(0);
+		}
+
+		if(nearestRefinery && nearestRefinery->getPos().getDistanceFrom(pos) <= minDist){
+			if(canUnload((int)ResourceType::REFINEDS)){
+				cargo[(int)ResourceType::REFINEDS] -= loadSpeed;
+				player->updateResource(ResourceType::REFINEDS, loadSpeed, true);
+				lastLoadTime = getTime();
+			}
+			else if(cargo[(int)ResourceType::REFINEDS] == 0 && nearestExtractor)
+				preparePathpoints(order, nearestExtractor->getPos());
+		}
+	}
+
+	void ResourceRover::handleResources(Order order){
+		float minDist = .5 * Map::getSingleton()->getCellSize().x;
+		
+		if(!pathPoints.empty())
+			navigate(minDist);
+		else if(order.type == Order::TYPE::SUPPLY)
+			collectRefineds(order, minDist);
+		else
+			loadResources((Structure*)order.targets[0].unit, minDist, order.type == Order::TYPE::LOAD);
 	}
 
 	void ResourceRover::update(){
@@ -100,7 +164,7 @@ namespace battleship{
 		vector<Player*> selectingPlayers = getSelectingPlayers();
 		bool mainPlayerSelecting = (activeState && find(selectingPlayers.begin(), selectingPlayers.end(), mainPlayer) != selectingPlayers.end());
 
-		Unit::displayUnitStats(loadForeground, loadBackground, load, capacity, mainPlayer == player && mainPlayerSelecting, Vector2(0, -10));
+		Unit::displayUnitStats(loadForeground, loadBackground, calcTotalLoad(), capacity, mainPlayer == player && mainPlayerSelecting, Vector2(0, -10));
 	}
 
 	Unit* ResourceRover::getClosestUnit(vector<Structure*> structs){

resourceRover.h

@@ -14,15 +14,20 @@ namespace battleship{
 			ResourceRover(Player*, int, vb01::Vector3, vb01::Quaternion, Unit::State = Unit::State::STAND_GROUND);
 			~ResourceRover();
 			void update();
+			inline int getLoad(int id){return cargo[id];}
+			inline int calcTotalLoad(){return cargo[0] + cargo[1] + cargo[2];}
+			inline int getCapacity(){return capacity;}
+			inline bool canLoad(){return vb01::getTime() - lastLoadTime > loadRate && calcTotalLoad() < capacity;}
+			inline bool canUnload(int id){return vb01::getTime() - lastLoadTime > loadRate && cargo[id] > 0;}
 		private:
 			void initProperties();
-			void supply(Order);
+			void collectRefineds(Order, float);
+			void loadResources(Structure*, float, bool);
+			void handleResources(Order);
 			Unit* getClosestUnit(std::vector<Structure*>);
-			inline bool canLoad(){return vb01::getTime() - lastLoadTime > loadRate && load < capacity;}
-			inline bool canUnload(){return vb01::getTime() - lastLoadTime > loadRate && load > 0;}
 
 			vb01::s64 lastLoadTime = 0;
-			int load = 0, capacity, loadRate, loadSpeed;
+			int cargo[3]{0, 0, 0}, capacity, loadRate, loadSpeed;
 			Extractor *nearestExtractor = nullptr; 
 			Unit *nearestRefinery = nullptr;
 			vb01::Node *loadBackground = nullptr, *loadForeground = nullptr;

tradeOffer.h

@@ -5,20 +5,22 @@
 
 namespace battleship{
 	struct TradeOffer{
-		Player *initPlayer = nullptr, *recPlayer = nullptr;
-		int initRefineds = 0, recRefineds = 0, initWealth = 0, recWealth = 0, initResearch = 0, recResearch = 0;
-		bool initPlAgreed = true, recPlAgreed = false;
+		bool sellerAggrees = true, sellerDelivers = true, buyerAggrees = true, buyerDelivers = false;
+		int tradeResources[NUM_RESOURCES][2], deliveredResources[NUM_RESOURCES][2];
 
-		TradeOffer(Player *ip, Player *rp, int ir, int rr, int iw, int rw, int it, int rt) : 
-			initPlayer(ip), 
-			recPlayer(rp), 
-			initRefineds(ir), 
-			recRefineds(rr), 
-			initWealth(iw), 
-			recWealth(rw), 
-			initResearch(it), 
-			recResearch(rr)
-		{}
+		TradeOffer(int br, int sr, int bw, int sw, int bt, int st){
+			tradeResources[(int)ResourceType::REFINEDS][0] = br;
+			tradeResources[(int)ResourceType::REFINEDS][1] = sr;
+			tradeResources[(int)ResourceType::WEALTH][0] = bw;
+			tradeResources[(int)ResourceType::WEALTH][1] = sw;
+			tradeResources[(int)ResourceType::RESEARCH][0] = bt;
+			tradeResources[(int)ResourceType::RESEARCH][1] = st;
+
+			for(int i = 0; i < NUM_RESOURCES; i++){
+				deliveredResources[i][0] = 0;
+				deliveredResources[i][1] = 0;
+			}
+		}
 	};
 }
 

tradingScreenButton.cpp

@@ -24,25 +24,29 @@ namespace battleship{
 	{}
 
 	void TradingScreenButton::onClick(){
+		generateView().script("playerId = " + to_string(playerId));
+
 		ConcreteGuiManager *guiManager = ConcreteGuiManager::getSingleton();
 		Game *game = Game::getSingleton();
 
+		StateManager *stateManager = GameManager::getSingleton()->getStateManager();
+		ActiveGameState *activeState = (ActiveGameState*)stateManager->getAppStateByType((int)AppStateType::ACTIVE_STATE);
+		activeState->setOfferScreen(true);
+
 		if(listbox->getNumLines() > 0){
-			StateManager *stateManager = GameManager::getSingleton()->getStateManager();
-			ActiveGameState *activeState = (ActiveGameState*)stateManager->getAppStateByType((int)AppStateType::ACTIVE_STATE);
 			Player *mainPlayer = activeState->getPlayer();
 			
-			TradeOffer *tradeOffer = game->findTradeOffers(mainPlayer, game->getPlayer(playerId))[listbox->getSelectedOption()];
+			TradeOffer *tradeOffer = mainPlayer->getTradeOffers(game->getPlayer(playerId))[listbox->getSelectedOption()];
 
 			ActiveStateButton::onClick();
 			vector<Textbox*> textboxes = guiManager->getTextboxes();
 			
-			textboxes[0]->setEntry(to_wstring(tradeOffer->recRefineds));
-			textboxes[1]->setEntry(to_wstring(tradeOffer->initRefineds));
-			textboxes[2]->setEntry(to_wstring(tradeOffer->recWealth));
-			textboxes[3]->setEntry(to_wstring(tradeOffer->initWealth));
-			textboxes[4]->setEntry(to_wstring(tradeOffer->recResearch));
-			textboxes[5]->setEntry(to_wstring(tradeOffer->initResearch));
+			textboxes[0]->setEntry(to_wstring(tradeOffer->tradeResources[0][0]));
+			textboxes[1]->setEntry(to_wstring(tradeOffer->tradeResources[0][1]));
+			textboxes[2]->setEntry(to_wstring(tradeOffer->tradeResources[1][0]));
+			textboxes[3]->setEntry(to_wstring(tradeOffer->tradeResources[1][1]));
+			textboxes[4]->setEntry(to_wstring(tradeOffer->tradeResources[2][0]));
+			textboxes[5]->setEntry(to_wstring(tradeOffer->tradeResources[2][1]));
 		}
 		else
 			ActiveStateButton::onClick();

unit.cpp

@@ -626,8 +626,11 @@ namespace battleship{
                 case Order::TYPE::LAUNCH:
                     launch(order);
                     break;
+                    break;
+                case Order::TYPE::LOAD:
                 case Order::TYPE::SUPPLY:
-                    supply(order);
+                case Order::TYPE::UNLOAD:
+                    handleResources(order);
                     break;
                 case Order::TYPE::HACK:
                     hack(order);
@@ -702,6 +705,8 @@ namespace battleship{
 					return false;
 				}
 		    case Order::TYPE::SUPPLY:
+		    case Order::TYPE::LOAD:
+		    case Order::TYPE::UNLOAD:
 				return unitClass == UnitClass::RESOURCE_ROVER;
 		    case Order::TYPE::HACK:
 				{

unit.h

@@ -37,7 +37,7 @@ namespace battleship{
 	class Projectile;
     
     struct Order {
-        enum class TYPE {ATTACK, BUILD, MOVE, GARRISON, EJECT, PATROL, LAUNCH, SUPPLY, HACK};
+        enum class TYPE {ATTACK, BUILD, MOVE, GARRISON, EJECT, PATROL, LAUNCH, SUPPLY, LOAD, UNLOAD, HACK};
 			struct Target{
 				Unit *unit = nullptr;
 				vb01::Vector3 pos;
@@ -53,9 +53,14 @@ namespace battleship{
         std::vector<Target> targets;
 
 		Order(){}
-		Order(TYPE t, std::vector<Target> targ, vb01::Vector3 dir = vb01::Vector3::VEC_ZERO, int lid = -1, bool pa = true) : type(t), playerAssigned(pa), lineId(lid), targets(targ), direction(dir){}
+		Order(TYPE t, std::vector<Target> targ, vb01::Vector3 dir = vb01::Vector3::VEC_ZERO, int lid = -1, bool pa = true) :
+		   	type(t), 
+			playerAssigned(pa), 
+			lineId(lid), 
+			targets(targ), 
+			direction(dir){}
     };
-    
+
     enum class MoveDir {LEFT, UP, FORW};
     enum class Corner {FRONT_LEFT, FRONT_RIGHT, REAR_LEFT, REAR_RIGHT};
     enum class UnitType {UNDERWATER, SEA_LEVEL, HOVER, LAND, AIR, NONE = -1};
@@ -204,7 +209,7 @@ namespace battleship{
         virtual void move(Order){}
         virtual void patrol(Order){}
         virtual void launch(Order);
-		virtual void supply(Order){}
+		virtual void handleResources(Order){}
 		virtual void hack(Order){}
 		float calculateRotation(vb01::Vector3, float, float);
 		void removeBar(vb01::Node*);