Packaging_Kernel.h
#pragma once
#include <string>
#include <map>
#include <vector>
#include "cocos2d.h"
#include "ui\CocosGUI.h"
#include "SimpleAudioEngine.h"
#include "cocostudio\CocoStudio.h"
#include "cocos\editor-support\spine\SkeletonAnimation.h"
#include "cocos\platform\desktop\CCGLViewImpl-desktop.h"
#include "cocos\math\CCGeometry.h"
#include "cocos\editor-support\spine\extension.h"
#include "cocos\math\Vec2.h"
#include "cocos2d/extensions/GUI/CCScrollView/CCTableView.h"
#include <iostream>
#include <windows.h>
#include <tchar.h>
using namespace std;
using namespace cocos2d;
using namespace cocostudio;
using namespace ui;
using namespace spine;
using namespace timeline;
using namespace CocosDenshion;
typedef struct MONITORBING
{
EventDispatcher *Dispatcher;
EventListenerMouse *ListenerMouse;
}MONITORBING, *LPMONITORBING;
typedef struct POKERS
{
int PokerColor = 0;
int CurState = 0;
int Poker = 0;
}Poker,*LPPoker;
typedef struct USERS
{
int PokerColor = 0;
int CurState = 0;
int Poker = 0;
}User,*LPUser;
typedef struct TOUCH
{
int KeyState = 0; //按下 1,移动 2,抬起 3
int KeyCode = 0;//保留
int TouchMove = 0;
int TouchEnd = 0;
Vec2 CurPos = Vec2::ZERO;
Vec2 LastPos = Vec2::ZERO;
}RecvTouch,*LPRecvTouch;
typedef struct COOR
{
int X;
int Y;
}Coor, Position;
//LPMONITORBING LPMonitorBing = new MONITORBING;
//LPMonitorBing->Dispatcher = Director::getInstance()->getEventDispatcher();
//LPMonitorBing->ListenerMouse = EventListenerMouse::create();
//LPMonitorBing->ListenerMouse->onMouseDown = CC_CALLBACK_1(HelloWorld::OnMouseDown, this);
//LPMonitorBing->Dispatcher->addEventListenerWithSceneGraphPriority(LPMonitorBing->ListenerMouse, this);
typedef void(*MOUSEEVENTFUNCTION)(Event*);
typedef void(*KEYEVENTFUNCTION)(EventKeyboard::KeyCode, Event*);
typedef bool(*TOUCHEVENTFUNCTION)(Touch*, Event*);
typedef void(*TOUCHEVENT_FUNCTION)(Touch*, Event*);
typedef void(*MENUITEMLABEL_FUNCTION)(Ref*);
class PackagingClass
{
//精灵
Sprite *m_Sprites = NULL;
Vec2 *m_SpritesPosition = NULL;
Vec2 *m_SpritesWidthAndHeight = NULL;
//纹理
Texture2D *m_Texture2D = NULL;
//粒子
//CCParticleExplosion //爆炸粒子特效
// CCParticleFire //火焰粒子特效
// CCParticleFlower //花束粒子特效
// CCParticleFireworks //烟花粒子特效
// CCParticleGalaxy //星系粒子特效
// CCParticleMeteor //流星粒子特效
// CCParticleRain //下雨粒子特效
// CCParticleSmoke //烟雾粒子特效
// CCParticleSnow //下雪粒子特效
// CCParticleSpiral //漩涡粒子特效
// CCParticleSun //太阳粒子特效
ParticleFireworks *m_ParticleEffects = NULL;
//遮罩
ClippingNode *m_MaskTier = NULL;//蒙版
Vec2 *m_ButtonPosition = NULL;
Vec2 *m_ButtonWidthAndHeight = NULL;
//音频
char m_MusicFile[256] = { 0 };
//动作
CallFunc *m_CallBackFunctionAction = NULL;//回调函数无参动作
DelayTime *m_DelayAction = NULL;//延时动作
Sequence *m_ConnectAction = NULL;//连接动作
RepeatForever *m_InfiniteAction = NULL;//无限动作
//树
std::map<std::string, Sprite*> m_MapSprite;//Map精灵
std::map<std::string, Texture2D*> m_MapTexture;//Map纹理
std::map<std::string, Button*> m_MapButton;//Map按钮
std::map<std::string, SkeletonAnimation*> m_MapSkeletonAnimation;//Map骨骼动画
std::map<Texture2D*, Sprite*> m_MapTextureSprite;//Map纹理精灵
//单子弹
std::vector<Sprite*> m_VectorBullet;//Vector子弹
//单敌机
std::vector<Sprite*> m_VectorEnemy;//Vector敌机
//双管子弹
std::vector<Sprite*> m_VectorBullet_One;//管子one
std::vector<Sprite*> m_VectorBullet_Two;//管子two
//Poker
Poker m_Poker[54];//54张
User m_UserLeft[20];
User m_MainUser[20];//地主
User m_UserRight[20];
//五子棋
static Vec2 m_StandardPos[11][11];
public:
PackagingClass();
~PackagingClass();
//单子弹功能
void Push_Back(Sprite *Sprites);
void UpdataBullet_Y_(Node *This, float Max_Y, float Speed);//当前节点,最大的Y,速度
void Delete_Bullet();//删除整个vector
//停用,Look Function Interior
void Delete_OneBullet(Node *This, std::vector<Sprite*>::iterator &it_);
std::vector<Sprite*> *Get_Bullet_it();
//单向基本的碰撞释放
void Release_One_AirAndBulletCrash(Node *This);
//敌机功能
void EnemyDirPush_Back(Sprite *Sprites);
void UpdataEnemyDir_Y_(Node *This,float X,float Y,float Max_Y,float Speed);
void Delete_EnemyDir();//删除整个vector
//停用,Look Function Interior
void Delete_OneEnemy(Node *This, std::vector<Sprite*>::iterator &it_);
std::vector<Sprite*> *Get_Enemy_it();
//双管子弹
void Push_Back(Sprite *Sprites_One,Sprite *Sprite_Two);
void UpdataDoubleBullet_Y_(Node *This, float Max_Y, float Speed);//当前节点,最大的Y,速度
void Delete_DoubleBullet();//删除整个vector
std::vector<Sprite*> *Get_Bullet_itOne();
std::vector<Sprite*> *Get_Bullet_itTwo();
//双管子弹的碰撞释放
void Release_Double_AirAndBulletCrash(Node *This);
//poker 洗牌
void InitShuffle();
//发牌
void Deal();
//排序
void User_Sort(User *MainUser, int Len);
//加载牌牌
void LoadPoker();
//显示牌牌
void ShowPoker(Node *This);
//返回牌牌
User *GetUserMainUser();
User *GetUserLeft();
User *GetUserRight();
//出牌牌后牌牌位置更新,在出牌后把CurState改为1,及把牌返回
void OutPokerPostionUpdata(User *Poker__,int Len,int Width,int W,int MainY, Node *This);//用处不是太大
//加载左边玩家的牌牌
void OutPokerLeftBackgroundUpdata(User *Poker_,int Len, Texture2D *Texture,Node *This);
//加载右边玩家的牌牌
void OutPokerRightBackgroundUpdata(User *Poker_, int Len, Texture2D *Texture, Node *This);
//五子棋
DrawNode* CreateGobangMap();
//标准坐标
static void StandardPos(Sprite *Sprites);
//根据文件创建一个精灵
Sprite* CreateSprite(const char *FileName, const Vec2 Position);
Sprite* CreateSprite(const char *FileName);
//根据文件获取一个精灵
Sprite* GetSprite(const char *FileName);
//根据文件获取精灵位置
Vec2 GetSpritePosition(const char *FileName);
//根据文件获取精灵宽高
Size GetSpriteWidthAndHeight(const char *FileName);
//根据文件创建一张纹理
Texture2D* CreateTexture2D(const char *FileName);
//根据文件获取一张纹理
Texture2D* GetTexture(const char *FileName);
//根据一张纹理创建一个精灵
Sprite* CreateTextureSprite(Texture2D *Texture);
//根据一张纹理获取一个纹理精灵
Sprite* GetTextureSprite(Texture2D *Texture);
//根据抬起图片获取按钮
Button* GetButton(const char *FileName);
//根据json文件获取一个骨骼动画
SkeletonAnimation* GetSkeletonAnimation(const char *FileName);
//创建遮罩层
ClippingNode* CreateMaskTier(const char *Template_FilePathName,//模板路径
Sprite *EffectsSprite,//特效精灵
Vec2 Template_Position,//模板位置
Vec2 Effects_Position);//特效精灵位置
ClippingNode* CreateMaskTier(Sprite *Template_Sprite,//模板精灵
Sprite *EffectsSprite,//特效精灵
Vec2 Template_Position,//模板位置
Vec2 Effects_Position);//特效精灵位置
//创建按钮
//注册事件加这一句
//参数 Ref* ref, TouchEventType *event
//->addTouchEventListener(this, toucheventselector(class::OnTouchButton));//虚函数
Button *CreateButton(Node *node,
const char *UpImageFileName,
const char *DownImageFileName,
const char *ProhibitImageFileName);
Button *CreateButton(const char *UpImageFileName,
const char *DownImageFileName,
const char *ProhibitImageFileName);
//创建一个ScrollView
ScrollView *CreateScrollView();
//创建一个Text
Label *CreateText(string Text, string Font, float Size = 50);
//加载csb动画(骨骼)
Node* LoadCSBAnimation(const char *FilePathName, Vec2 Position, const float SizeScale, const float TimeSpeed, bool Bool);
//加载 .json + .stlas 文件动画
SkeletonAnimation* Load_jsonAndStlas_Animation(const char *FilePathName_Json, const char *FilePathName_Atlas, Vec2 Position, const float TimeSpeed, bool Bool, const char *JsonIndex);
//加载 .plist + .png 帧动画
Sprite* Load_PlistAndPng_Animation(const char *FilePathName, Vec2 Position, const int EndFrame, char *XmlImageName);
//注册鼠标事件
void RegisterMouseEvent(Node *node,//this
MOUSEEVENTFUNCTION OnMouseDown,//成员函数必须是静态
MOUSEEVENTFUNCTION OnMouseUp,//成员函数必须是静态
MOUSEEVENTFUNCTION OnMouseMove,//成员函数必须是静态
MOUSEEVENTFUNCTION OnMouseScroll);//成员函数必须是静态
void RegisterMouseEvent(Node *node,
MOUSEEVENTFUNCTION OnMouseDown,//成员函数必须是静态
MOUSEEVENTFUNCTION OnMouseUp,//成员函数必须是静态
MOUSEEVENTFUNCTION OnMouseMove);//成员函数必须是静态
//注册按键事件
void RegisterKeyEvent(Node *node,//this
KEYEVENTFUNCTION KeyDown,//成员函数必须是静态
KEYEVENTFUNCTION KeyUp);//成员函数必须是静态
//注册触摸单点事件
void RegisterTouchEvent(Node *node,
TOUCHEVENTFUNCTION OnTouchBegin,//成员函数必须是静态
TOUCHEVENT_FUNCTION OnTouchMove,//成员函数必须是静态
TOUCHEVENT_FUNCTION OnTouchEnd);//成员函数必须是静态
void RegisterTouchEvent(Node *node,
TOUCHEVENTFUNCTION OnTouchBegin,//成员函数必须是静态
TOUCHEVENT_FUNCTION OnTouchMove,//成员函数必须是静态
TOUCHEVENT_FUNCTION OnTouchEnd,//成员函数必须是静态
TOUCHEVENT_FUNCTION OnTouchCancelle);//成员函数必须是静态
//播放音乐
char *PlayBackgroundMusic(const char *BackgroundMusicName, bool Loop = true);
//暂停音乐
void PauseBackgroundMusic();
//注册每一帧调用：void class::Update(float Time);
static void RegisterEachFrameCall(Node *node);
//开启控制台,最好放在Main函数里
void OpenConsole();
void OpenConsole2();
//切换场景
static void ChangeScene(Scene* scene);
//触摸移动
static void TouchMoveSprite(Touch *touch,Sprite* Sprites);
static void TouchMoveSprite(Touch *touch, Sprite* Sprites,void *null);
//Menu菜单
Menu *CreateMenu();
//用某个节点创建菜单项
MenuItemLabel *InsertMenuItemLabel(Node *node);
//注册菜单项回调
void RegisterMenuItemLabel(MenuItemLabel* MenuItemLabel,
MENUITEMLABEL_FUNCTION MenuItemCallback);//成员函数必须是静态
//布局,注意是堆内存,用完后注意注意注意释放
Position *OverallArrangemet(int Number);
protected:
//鼠标按下
static void _OnMouseDown(MOUSEEVENTFUNCTION OnMouseDown, Event *event);
//鼠标抬起
static void _OnMouseUp(MOUSEEVENTFUNCTION OnMouseUp, Event *event);
//鼠标移动
static void _OnMouseMove(MOUSEEVENTFUNCTION OnMouseMove, Event *event);
//鼠标滚轮
static void _OnMouseScroll(MOUSEEVENTFUNCTION OnMouseScroll, Event *event);
//按键按下
static void _OnKeyPressed(KEYEVENTFUNCTION OKeyDown, EventKeyboard::KeyCode KeyCode, Event *event);
//按键抬起
static void _OnKeyReleased(KEYEVENTFUNCTION OKeyUp, EventKeyboard::KeyCode KeyCode, Event *event);
//触摸开始
static bool _OnTouchBegin(TOUCHEVENTFUNCTION OnTouchBegin, Touch *touch, Event *event);
//触摸移动
static void _OnTouchMove(TOUCHEVENT_FUNCTION OnTouchMove, Touch *touch, Event *event);
//触摸结束
static void _OnTouchEnd(TOUCHEVENT_FUNCTION OnTouchEnd, Touch *touch, Event *event);
//触摸取消
static void _OnTouchCancelle(TOUCHEVENT_FUNCTION OnTouchCancelle, Touch *touch, Event *event);
private:
BOOL InsertionSprite(std::string Name, Sprite *Sprites);
BOOL InsertionTexture(std::string Name, Texture2D *Texture);
BOOL InsertionButton(std::string Name,Button *button);
BOOL InsertionSkeletonAnimation(std::string Name, SkeletonAnimation *Skeleton_Animation);
BOOL InsertionTextureSprite(Texture2D *Texture,Sprite *Sprites);
};
//9宫格精灵
//Scale9Sprite *S = Scale9Sprite::create("_9.png");
//S->setPosition(Vec2((visibleSize / 2).width, (visibleSize / 2).height));
//S->setCapInsets(CCRectMake(0,0,0,0));
//S->setContentSize(Size::Size(800,600));
//this->addChild(S);
//自定义监听事件
//Button *Btn = m_Obj->CreateButton(this, "ButtonFile/game_6.png", "ButtonFile/game_27.png", "ButtonFile/game_187.png");
//Btn->addTouchEventListener(this, toucheventselector(HelloWorld::OnTouchButton));
//auto listener = EventListenerCustom::create("Event",
// [](EventCustom*)
//{
// CCLOG("===========>Event");
//});
//Director::getInstance()->getEventDispatcher()->addEventListenerWithFixedPriority(listener, 1);
//Director::getInstance()->getEventDispatcher()->dispatchCustomEvent("Event");
//多点触控
//EventListenerTouchAllAtOnce *Listener = EventListenerTouchAllAtOnce::create();
//Listener->onTouchesBegan = [=](const std::vector<Touch*>& touch, Event* event)
//{
// CCLOG("Touches count %lu", touch.size());
// Touch *t;
// for (auto it = touch.begin(); it != touch.end(); it++)
// {
// t = *it;
// CCLOG("X = %f , Y = %f", t->getLocation().x, t->getLocation().y);
// }
//};
//Director::getInstance()->getEventDispatcher()->addEventListenerWithSceneGraphPriority(Listener, this);
//==============================================成员函数调用约定
#define Updata update(float Time)
#define __BUTTONCLASS__(__CLASS__) \
toucheventselector(__CLASS__::OnTouchButton)
#define ONTOUCHBUTTON(__CLASS__)\
__CLASS__::OnTouchButton
#define ONMOUSEDOWN(__CLASS__)\
__CLASS__::OnMouseDown
#define ONMOUSEUP(__CLASS__)\
__CLASS__::OnMouseUp
#define ONMOUSEMOVE(__CLASS__)\
__CLASS__::OnMouseMove
#define ONMOUSESCROLL(__CLASS__)\
__CLASS__::OnMouseScroll
#define ONTOUCHBEGIN(__CLASS__)\
__CLASS__::OnTouchBegin
#define ONTOUCHMOVE(__CLASS__)\
__CLASS__::OnTouchMove
#define ONTOUCHEND(__CLASS__)\
__CLASS__::OnTouchEnd
#define ONTOUCHCANCELLE(__CLASS__)\
__CLASS__::OnTouchCancelle
#define ONKEYPRESSED(__CLASS__)\
__CLASS__::OnKeyPressed
#define ONKEYRELEASED(__CLASS__)\
__CLASS__::OnKeyReleased
//static void OnMouseDown(Event *event);
//static void OnMouseUp(Event *event);
//static void OnMouseMove(Event *event);
//
//static void OnKeyPressed(EventKeyboard::KeyCode keycode, Event *event);
//static void OnKeyReleased(EventKeyboard::KeyCode keycode, Event *event);
//
//static bool OnTouchBegin(Touch *touch, Event *event);
//static void OnTouchMove(Touch *touch, Event *event);
//static void OnTouchEnd(Touch *touch, Event *event);
//static void OnTouchCancelle(Touch *touch, Event *event);
//
//void Main::OnMouseDown(Event *event)
//{
// EventMouse *M = (EventMouse*)event;
//
// CCLOG("MouseDown");
// m_State = 1;
//}
//void Main::OnMouseUp(Event *event)
//{
// CCLOG("MouseUp");
//}
//void Main::OnMouseMove(Event *event)
//{
// CCLOG("MouseMove");
//}
//
//void Main::OnTouchButton(Ref* ref, TouchEventType *event)
//{
// std::cout << ((Widget*)ref)->getTouchMovePosition().x << " " << ((Widget*)ref)->getTouchMovePosition().y<< std::endl;
// int var = 0;
//}
//
//void Main::OnKeyPressed(EventKeyboard::KeyCode keycode, Event *event)
//{
//
// if (keycode == EventKeyboard::KeyCode::KEY_UP_ARROW)
// {
// CCLOG("KeyDown %d", keycode);
// }
// if (keycode == EventKeyboard::KeyCode::KEY_DOWN_ARROW)
// {
// CCLOG("KeyDown %d", keycode);
// }
// if (keycode == EventKeyboard::KeyCode::KEY_LEFT_ARROW)
// {
// CCLOG("KeyDown %d", keycode);
// }
// if (keycode == EventKeyboard::KeyCode::KEY_RIGHT_ARROW)
// {
// CCLOG("KeyDown %d", keycode);
//
// }
//
//}
//void Main::OnKeyReleased(EventKeyboard::KeyCode keycode, Event *event)
//{
// CCLOG("KeyUp %d", keycode);
//}
//
//bool Main::OnTouchBegin(Touch *touch, Event *event)
//{
// CCLOG("Touch %f,%f", touch->getLocation().x, touch->getLocation().y);
// CCLOG("OnTouchBegan");
// return true;
//}
//void Main::OnTouchMove(Touch *touch, Event *event)
//{
// CCLOG("onTouchMoved");
//}
//void Main::OnTouchEnd(Touch *touch, Event *event)
//{
// CCLOG("onTouchEnded");
//}
//void Main::OnTouchCancelle(Touch *touch, Event *event)
//{
// CCLOG("OnTouchCancelled");
//}
//void Main::menuCloseCallback(Ref* pSender)
//{
// Director::getInstance()->end();
// m_GameLogScene.EndGame_LogScene(this);
//
//#if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS)
// exit(0);
//#endif
//
//}
Packaging_Kernel.cpp
#include "Packaging_Kernel.h"
Vec2 PackagingClass::m_StandardPos[11][11] = { Vec2::ZERO };
PackagingClass::PackagingClass()
{
srand(GetTickCount());
}
PackagingClass::~PackagingClass()
{
PackagingClass::Delete_Bullet();
PackagingClass::Delete_EnemyDir();
PackagingClass::Delete_DoubleBullet();
}
BOOL PackagingClass::InsertionSprite(std::string Name, Sprite *Sprites)
{
if (Sprites != NULL)
{
m_MapSprite.insert(std::pair<std::string, Sprite*>(Name, Sprites));
return TRUE;
}
return FALSE;
}
BOOL PackagingClass::InsertionTexture(std::string Name, Texture2D *Texture)
{
if (Texture != NULL)
{
m_MapTexture.insert(std::pair<std::string, Texture2D*>(Name, Texture));
return TRUE;
}
return FALSE;
}
BOOL PackagingClass::InsertionButton(std::string Name, Button *button)
{
if (button != NULL)
{
m_MapButton.insert(std::pair<std::string, Button*>(Name, button));
return TRUE;
}
return FALSE;
}
BOOL PackagingClass::InsertionSkeletonAnimation(std::string Name, SkeletonAnimation *Skeleton_Animation)
{
if (Skeleton_Animation != NULL)
{
m_MapSkeletonAnimation.insert(std::pair<std::string, SkeletonAnimation*>(Name, Skeleton_Animation));
}
return FALSE;
}
BOOL PackagingClass::InsertionTextureSprite(Texture2D *Texture, Sprite *Sprites)
{
if (Texture != NULL && Sprites != NULL)
{
m_MapTextureSprite.insert(std::pair<Texture2D*, Sprite*>(Texture, Sprites));
return TRUE;
}
return FALSE;
}
Sprite* PackagingClass::CreateSprite(const char *FileName, const Vec2 Position)
{
if (FileName != NULL)
{
m_Sprites = Sprite::create(FileName);
m_Sprites->setPosition(Position);
PackagingClass::InsertionSprite(FileName, m_Sprites);
return m_Sprites;
}
return NULL;
}
Sprite* PackagingClass::CreateSprite(const char *FileName)
{
if (FileName != NULL)
{
m_Sprites = Sprite::create(FileName);
m_Sprites->setPosition(Vec2::ZERO);
PackagingClass::InsertionSprite(FileName, m_Sprites);
return m_Sprites;
}
return NULL;
}
Sprite* PackagingClass::GetSprite(const char *FileName)
{
if (FileName != NULL)
{
if (m_MapSprite[FileName])
{
return m_MapSprite[FileName];
}
}
return NULL;
}
Texture2D* PackagingClass::GetTexture(const char *FileName)
{
if (FileName != NULL)
{
if (m_MapTexture[FileName])
{
return m_MapTexture[FileName];
}
}
return FALSE;
}
Vec2 PackagingClass::GetSpritePosition(const char *FileName)
{
if (FileName != NULL)
{
if (m_MapSprite[FileName])
{
return m_MapSprite[FileName]->getPosition();
}
}
return Vec2::ZERO;
}
Size PackagingClass::GetSpriteWidthAndHeight(const char *FileName)
{
if (FileName != NULL)
{
if (m_MapSprite[FileName])
{
return m_MapSprite[FileName]->getContentSize();
}
}
return Size::ZERO;
}
Texture2D* PackagingClass::CreateTexture2D(const char *FileName)
{
if (FileName != NULL)
{
m_Texture2D = TextureCache::getInstance()->addImage(FileName);
if (m_Texture2D)
{
PackagingClass::InsertionTexture(FileName, m_Texture2D);
return m_Texture2D;
}
}
return NULL;
}
Sprite* PackagingClass::CreateTextureSprite(Texture2D *Texture)
{
if (Texture != NULL)
{
Sprite* Sprites = Sprite::createWithTexture(Texture);
if (Sprites)
{
PackagingClass::InsertionTextureSprite(Texture, Sprites);
Sprites->setPosition(Vec2::ZERO);
return Sprites;
}
}
return NULL;
}
Button* PackagingClass::GetButton(const char *FileName)
{
if (FileName != NULL)
{
if (m_MapButton[FileName])
{
return m_MapButton[FileName];
}
}
return NULL;
}
SkeletonAnimation* PackagingClass::GetSkeletonAnimation(const char *FileName)
{
if (FileName != NULL)
{
if (m_MapSkeletonAnimation[FileName])
{
return m_MapSkeletonAnimation[FileName];
}
}
return NULL;
}
Sprite* PackagingClass::GetTextureSprite(Texture2D *Texture)
{
if (Texture != NULL)
{
if (m_MapTextureSprite[Texture])
{
return m_MapTextureSprite[Texture];
}
}
return NULL;
}
ClippingNode* PackagingClass::CreateMaskTier(const char *Template_FilePathName,
Sprite *EffectsSprite,
Vec2 Template_Position,
Vec2 Effects_Position)
{
if (Template_FilePathName && EffectsSprite)
{
Sprite *Template = PackagingClass::CreateSprite(Template_FilePathName);
Template->setPosition(Template_Position);
EffectsSprite->setPosition(Effects_Position);
ClippingNode *MaskTier = ClippingNode::create();
MaskTier->setAlphaThreshold(0.5f);
MaskTier->setInverted(false);
MaskTier->addChild(EffectsSprite);
MaskTier->setStencil(Template);
m_MaskTier = MaskTier;
return MaskTier;
}
return NULL;
}
ClippingNode* PackagingClass::CreateMaskTier(Sprite *Template_Sprite,//模板精灵
Sprite *EffectsSprite,//特效精灵
Vec2 Template_Position,//模板位置
Vec2 Effects_Position)//特效精灵位置
{
if (Template_Sprite && EffectsSprite)
{
Template_Sprite->setPosition(Template_Position);
EffectsSprite->setPosition(Effects_Position);
ClippingNode *MaskTier = ClippingNode::create();
MaskTier->setAlphaThreshold(0.5f);
MaskTier->setInverted(false);
MaskTier->addChild(EffectsSprite);
MaskTier->setStencil(Template_Sprite);
m_MaskTier = MaskTier;
return MaskTier;
}
return NULL;
}
Node* PackagingClass::LoadCSBAnimation(const char *FilePathName,
Vec2 Position,
const float SizeScale,
const float TimeSpeed,
bool IsLoop)
{
if (FilePathName != NULL)
{
Node *CSB = CSLoader::createNode(FilePathName);
CSB->setPosition(Position);
CSB->setScale(SizeScale);
ActionTimeline *Action_Animation = CSLoader::createTimeline(FilePathName);
Action_Animation->setTimeSpeed(TimeSpeed);
CSB->runAction(Action_Animation);
Action_Animation->gotoFrameAndPlay(0, IsLoop);
return CSB;
}
return NULL;
}
SkeletonAnimation* PackagingClass::Load_jsonAndStlas_Animation(const char *FilePathName_Json,
const char *FilePathName_Atlas,
Vec2 Position, const float TimeSpeed,
bool IsLoop, const char *JsonIndex)
{
if (FilePathName_Atlas != NULL && FilePathName_Json != NULL)
{
SkeletonAnimation *Skeleton_Animation = SkeletonAnimation::createWithFile(FilePathName_Json, FilePathName_Atlas);
Skeleton_Animation->setPosition(Position);
Skeleton_Animation->setTimeScale(TimeSpeed);
Skeleton_Animation->setAnimation(0, JsonIndex, IsLoop);
PackagingClass::InsertionSkeletonAnimation(FilePathName_Json, Skeleton_Animation);
return Skeleton_Animation;
}
return NULL;
}
Sprite* PackagingClass::Load_PlistAndPng_Animation(const char *FilePathName,
Vec2 Position,
const int EndFrame,
char *XmlImageName)
{
if (FilePathName != NULL && XmlImageName != NULL)
{
SpriteFrameCache *Sprite_Frame = SpriteFrameCache::getInstance();
Sprite_Frame->addSpriteFramesWithFile(FilePathName);//"Animation\\Plist.plist"
char Name[64] = { 0 };
Vector<SpriteFrame*> Vec;
for (int i = 0; i < EndFrame; i++)
{
sprintf_s(Name, XmlImageName, i);//"image/boss_spider-angry_%d.png"
Vec.pushBack(Sprite_Frame->getSpriteFrameByName(Name));
}
Animation *animation = Animation::createWithSpriteFrames(Vec, 0.1f);
Animate *animate = Animate::create(animation);
Sprite *sprite = Sprite::create();
sprite->setPosition(Position);
sprite->runAction(RepeatForever::create(animate));
return sprite;
}
return NULL;
}
//播放音乐
char *PackagingClass::PlayBackgroundMusic(const char *BackgroundMusicName, bool Loop)
{
if (BackgroundMusicName)
{
for (int i = 0; i < 256; i++)
{
if (!BackgroundMusicName[i])
{
break;
}
m_MusicFile[i] = BackgroundMusicName[i];
}
SimpleAudioEngine::getInstance()->playBackgroundMusic(FileUtils::getInstance()->fullPathForFilename(m_MusicFile).c_str(), Loop);
return m_MusicFile;
}
return NULL;
}
void PackagingClass::PauseBackgroundMusic()
{
SimpleAudioEngine::getInstance()->pauseBackgroundMusic();
}
//创建按钮
Button *PackagingClass::CreateButton(Node *node,
const char *UpImageFileName,
const char *DownImageFileName,
const char *ProhibitImageFileName)
{
//注册事件加这一句
//参数 Ref* ref, TouchEventType *event
//->addTouchEventListener(this, toucheventselector(class::OnTouchButton));//虚函数
Button *Buttons = Button::create();
Buttons->loadTextureNormal(UpImageFileName);
Buttons->loadTexturePressed(DownImageFileName);
Buttons->loadTextureDisabled(ProhibitImageFileName);
Buttons->setPosition(Vec2::ZERO);
//此方法为无参的回调
//Buttons->addClickEventListener();
node->addChild(Buttons);
PackagingClass::InsertionButton(UpImageFileName, Buttons);
return Buttons;
}
Button *PackagingClass::CreateButton(const char *UpImageFileName,
const char *DownImageFileName,
const char *ProhibitImageFileName)
{
//注册事件加这一句
//参数 Ref* ref, TouchEventType *event
//->addTouchEventListener(this, toucheventselector(class::OnTouchButton));//虚函数
Button *Buttons = Button::create();
Buttons->loadTextureNormal(UpImageFileName);
Buttons->loadTexturePressed(DownImageFileName);
Buttons->loadTextureDisabled(ProhibitImageFileName);
Buttons->setPosition(Vec2::ZERO);
//此方法为无参的回调
//Buttons->addClickEventListener();
PackagingClass::InsertionButton(UpImageFileName, Buttons);
return Buttons;
}
//开启控制台
void PackagingClass::OpenConsole()
{
#ifdef WIN32
_tsetlocale(LC_ALL, _T(" "));
::AllocConsole();
::freopen("CONIN$", "r", stdin);
::freopen("CONOUT$", "w", stdout);
::freopen("CONOUT$", "w", stderr);
#endif // WIN32
}
void PackagingClass::OpenConsole2()
{
#ifdef WIN32
::AllocConsole();
::freopen("CONIN$", "r", stdin);
::freopen("CONOUT$", "w", stdout);
::freopen("CONOUT$", "w", stderr);
#endif // WIN32
}
//创建一个ScrollView
ScrollView *PackagingClass::CreateScrollView()
{
ScrollView *ScrollViews = ScrollView::create();
//开启触摸
ScrollViews->setTouchEnabled(true);
//开启反弹
ScrollViews->setBounceEnabled(true);
//设置为垂直滚动
ScrollViews->setDirection(ScrollView::Direction::VERTICAL);
//设置显示的大小
ScrollViews->setContentSize(Size(200, 500));
//设置滚动容器的大小
ScrollViews->setInnerContainerSize(Size(200, 100));
//设置滚动条颜色
ScrollViews->setScrollBarColor(Color3B::BLUE);
//设置位置
ScrollViews->setPosition(Vec2(200, 0));
//设置是否开启滚动惯性
ScrollViews->setInertiaScrollEnabled(true);
//void setBounceEnabled(bool enabled)
// 设置当滚动到边界时，是否内部容器发生弹回(bounce)效果
// bool isBounceEnabled() const
// 获取边界弹回(bounce)状态。
// void setInertiaScrollEnabled(bool enabled)
// 设置是否开启滚动惯性。
// bool isInertiaScrollEnabled() const
// 获取滚动视图是否开启滚动惯性。
// void setScrollBarEnabled(bool enabled)
// 设置是否启用滚动条。
// bool isScrollBarEnabled() const
// 返回滚动条是否启用。
// virtual void setDirection(Direction dir)
// 改变滚动视图的方向。
// Direction getDirection() const
// 获取滚动视图的滚动方向。
// Layout * getInnerContainer() const
// 获取滚动视图的内部布局容器，该布局容器为滚动视图的子节点。
// //与滚动方位有关
// void scrollToPercentVertical(float percent, float second, bool attenuated)
// 按百分比竖直滚动内部布局容器
// void scrollToPercentHorizontal(float percent, float second, bool attenuated)
// 按百分比水平滚动内部布局容器
// void scrollToPercentBothDirection(const Vec2 &percent, float second, bool attenuated)
// 在竖直方向和水平方向分别按一定的百分比滚动内部布局容器
// void scrollToBottom(float second, bool attenuated)
// 将内部的布局容器滚动到滚动视图的底部边界。
// void scrollToTop(float second, bool attenuated)
// 将内部布局容器滚动到滚动视图的顶部边界。
// void scrollToLeft(float second, bool attenuated)
// 将内部容器滚动到滚动视图的左端边界
// void scrollToRight(float time, bool attenuated)
// 将内部布局容器滚动到滚动视图的右端边界
// void scrollToTopLeft(float second, bool attenuated)
// 滚动内部布局容器到滚动视图的左上角
// void scrollToTopRight(float time, bool attenuated)
// 滚动内部布局容器到滚动使徒的右上角
// void scrollToBottomLeft(float second, bool attenuated)
// 滚动内部布局容器到视图的左下角
// void scrollToBottomRight(float time, bool attenuated)
// 滚动内部布局容器到视图的右下角
// //与滚动条样式有关
// void setScrollBarPositionFromCorner(const Vec2 &positionFromCorner)
// 设置滚动条水平位置和垂直位置。
// void setScrollBarPositionFromCornerForVertical(const Vec2 &positionFromCorner)
// 设置滚动条垂直位置。
// Vec2 getScrollBarPositionFromCornerForVertical() const
// 获得滚动条垂直位置。
// void setScrollBarPositionFromCornerForHorizontal(const Vec2 &positionFromCorner)
// 设置滚动条水平位置。
// Vec2 getScrollBarPositionFromCornerForHorizontal() const
// 获得滚动条水平位置。
// void setScrollBarWidth(float width)
// 设置滚动条宽度。
// float getScrollBarWidth() const
// 获取滚动条宽度。
// void setScrollBarColor(const Color3B &color)
// 设置滚动条颜色。
// const Color3B & getScrollBarColor() const
// 获取滚动条颜色。
// void setScrollBarOpacity(GLubyte opacity)
// 设置滚动条透明度。
// GLubyte getScrollBarOpacity() const
// 获取滚动条透明度。
// void setScrollBarAutoHideEnabled(bool autoHideEnabled)
// 设置滚动条自动隐藏状态。
// bool isScrollBarAutoHideEnabled() const
// 获取滚动条是否自动隐藏。
// void setScrollBarAutoHideTime(float autoHideTime)
// 设置滚动条自动隐藏时间。
// float getScrollBarAutoHideTime() const
// 获取滚动条是否自动隐藏。
// //
// void jumpToBottom()
// 将内部布局容器移至视图底端。
// void jumpToTop()
// 将内部布局容器移至视图顶端。
// void jumpToLeft()
// 将内部布局容器移至视图左端。
// void jumpToRight()
// 将内部布局容器移至视图右端。
// void jumpToTopLeft()
// 将内部布局容器移至视图的左上角。
// void jumpToTopRight()
// 将内部布局容器移至视图的右上角。
// void jumpToBottomLeft()
// 将内部布局容器移至视图的左下角。
// void jumpToBottomRight()
// 将内部布局容器移至视图的右下角。
// void jumpToPercentVertical(float percent)
// 按一定的百分比竖直滚动视图内的布局容器。
// void jumpToPercentHorizontal(float percent)
// 按一定的百分比竖直滚动视图内的布局容器。
// void jumpToPercentBothDirection(const Vec2 &percent)
// 竖直方向和水平方向分别按一定的百分比滚动容器。
// void setInnerContainerSize(const Size &size)
// 设置滚动容器的滚动区域大小。
// const Size & getInnerContainerSize() const
// 获取滚动容器的滚动区域大小。
// void setInnerContainerPosition(const Vec2 &pos)
// 设置容器内的位置。
// const Vec2 getInnerContainerPosition() const
// 获取容器内的位置。
// void addEventListenerScrollView(Ref *target, SEL_ScrollViewEvent selector)
// 添加一个回调函数，该回调函数将会在视图发生滚动时触发。
// virtual void addEventListener(const ccScrollViewCallback &callback)
// 添加一个回调函数，该回调函数将在滚动事件触发时被调用。
return ScrollViews;
}
//创建一个Text
Label *PackagingClass::CreateText(string Text, string Font, float Size)
{
//暂时的两种方法
Label *Labels = Label::createWithTTF(Text, Font, Size);
//Label *Labels = Label::createWithSystemFont(Text,Font, 30);
Labels->setPosition(Vec2(0, 0));
Labels->setColor(Color3B::YELLOW);
return Labels;
}
//切换场景
void PackagingClass::ChangeScene(Scene* scene)
{
Director::getInstance()->replaceScene(TransitionPageTurn::create(2, scene, false));
// CCTransitionJumpZoom
// 作用： 创建一个跳动的过渡动画
// 参数1：过渡动作的时间
// 参数2：切换到目标场景的对象
// reScene = CCTransitionJumpZoom ::create(t , s);
// CCDirector::sharedDirector()->replaceScene(reScene);
// CCTransitionProgressRadialCCW
// 作用： 创建一个扇形条形式的过渡动画， 逆时针方向
// 参数1：过渡动作的时间
// 参数2：切换到目标场景的对象
// reScene = CCTransitionProgressRadialCCW::create(t, s);
// CCDirector::sharedDirector()->replaceScene(reScene);
// CCTransitionProgressRadialCW
// 作用： 创建一个扇形条形式的过渡动画， 顺时针方向
// 参数1：过渡动作的时间
// 参数2：切换到目标场景的对象
// reScene = CCTransitionProgressRadialCW::create(t,s);
// CCDirector::sharedDirector()->replaceScene(reScene);
// CCTransitionProgressHorizontal
// 作用： 创建一个水平条形式的过渡动画，
// 参数1：过渡动作的时间
// 参数2：切换到目标场景的对象
// reScene = CCTransitionProgressHorizontal ::create(t,s);
// CCDirector::sharedDirector()->replaceScene(reScene);
// CCTransitionProgressVertical
// 作用： 创建一个垂直条形式的过渡动画，
// 参数1：过渡动作的时间
// 参数2：切换到目标场景的对象
// reScene = CCTransitionProgressVertical::create(t, s);
// CCDirector::sharedDirector()->replaceScene(reScene);
// CCTransitionProgressInOut
// 作用： 创建一个由里向外扩展的过渡动画，
// 参数1：过渡动作的时间
// 参数2：切换到目标场景的对象
// reScene = CCTransitionProgressInOut::create(t, s);
// CCDirector::sharedDirector()->replaceScene(reScene);
// CCTransitionProgressOutIn
// 作用： 创建一个由外向里扩展的过渡动画，
// 参数1：过渡动作的时间
// 参数2：切换到目标场景的对象
// reScene = CCTransitionProgressOutIn::create(t, s);
// CCDirector::sharedDirector()->replaceScene(reScene);
// CCTransitionCrossFade
// 作用：创建一个逐渐透明的过渡动画
// 参数1：过渡动作的时间
// 参数2：切换到目标场景的对象
// reScene = CCTransitionCrossFade::create(t, s);
// CCDirector::sharedDirector()->replaceScene(reScene);
// CCTransitionPageTurn
// 作用：创建一个翻页的过渡动画
// 参数1：过渡动作持续的时间
// 参数2：切换的目标场景的对象
// 参数3：是否逆向翻页
// reScene = CCTransitionPageTurn::create(t, s, false);
// CCDirector::sharedDirector()->replaceScene(reScene);
// CCTransitionFadeTR
// 作用：创建一个部落格过渡动画， 从左下到右上
// 参数1：过渡动作持续的时间
// 参数2：切换的目标场景的对象
// reScene =CCTransitionFadeTR::create(t, s);
// CCDirector::sharedDirector()->replaceScene(reScene);
// CCTransitionFadeBL
// 作用：创建一个部落格过渡动画， 从右上到左下
// 参数1：过渡动作持续的时间
// 参数2：切换的目标场景的对象
// reScene = CCTransitionFadeBL::create(t, s);
// CCDirector::sharedDirector()->replaceScene(reScene);
// CCTransitionFadeUp
// 作用：创建一个从下到上，条形折叠的过渡动画
// 参数1：过渡动作持续的时间
// 参数2：切换的目标场景的对象
// reScene= CCTransitionFadeUp::create(t, s);
// CCDirector::sharedDirector()->replaceScene(s);
// CCTransitionFadeDown
// 作用：创建一个从上到下，条形折叠的过渡动画
// 参数1：过渡动作持续的时间
// 参数2：切换的目标场景的对象
// reScene = CCTransitionFadeDown::create(t, s);
// CCDirector::sharedDirector()->replaceScene(reScene);
// CCTransitionTurnOffTiles
// 作用：创建一个随机方格消失的过渡动画
// 参数1：过渡动作的持续时间
// 参数2：切换的目标场景的对象
// reScene= CCTransitionTurnOffTiles::create(t, s);
// CCDirector::sharedDirector()->replaceScene(reScene);
// CCTransitionSplitRows
// 作用：创建一个分行划分切换的过渡动画
// 参数1：过渡动作的持续时间
// 参数2：切换的目标场景的对象
// reScene = CCTransitionSplitRows::create(t, s);
// CCDirector::sharedDirector()->replaceScene(reScene);
// CCTransitionSplitCols
// 作用：创建一个分列划分切换的过渡动画
// 参数1：过渡动作的持续时间
// 参数2：切换的目标场景的对象
// reScene = CCTransitionSplitCols::create(t, s);
// CCDirector::sharedDirector()->replaceScene(reScene);
// CCTransitionFade
// 作用：创建一个逐渐过渡到目标颜色的切换动画
// 参数1：过渡动作的持续时间
// 参数2：切换的目标场景的对象
// 参数3：目标颜色
// reScene= CCTransitionFade::create(t, s, ccc3(255, 0, 0));
// CCDirector::sharedDirector()->replaceScene(reScene);
// CCTransitionFlipX
// 作用：创建一个x轴反转的切换动画
// 参数1：过渡动作的持续时间
// 参数2：切换的目标场景的对象
// 参数3：反转类型的枚举变量 左右上下
// kOrientationDownOver kOrientationLeftOver kOrientationRightOver kOrientationUpOver
// reScene = CCTransitionFlipX::create(t, s, kOrientationRightOver);
// CCDirector::sharedDirector()->replaceScene(reScene);
// CCTransitionFlipY
// 参数1：过渡动作的持续时间
// 参数2：切换的目标场景的对象
// 参数3：反转类型的枚举变量 左右上下
// reScene = CCTransitionFlipY::create(t, s
// , kOrientationDownOver);
// CCDirector::sharedDirector()->replaceScene(reScene);
// CCTransitionFlipAngular
// 作用：创建一个带有反转角切换动画
// 参数1：过渡动作的持续时间
// 参数2：切换的目标场景的对象
// 参数3：反转类型的枚举变量 左右上下
// reScene = CCTransitionFlipAngular::create(t, s, kOrientationLeftOver);
// CCDirector::sharedDirector()->replaceScene(reScene);
// CCTransitionZoomFlipX
// 作用：创建一个带有缩放的x轴反转切换的动画
// 参数1：过渡动作的持续时间
// 参数2：切换的目标场景的对象
// 参数3：反转类型的枚举变量 左右上下
// reScene=CCTransitionZoomFlipX::create(t, s, kOrientationLeftOver);
// CCDirector::sharedDirector()->replaceScene(reScene);
// CCTransitionZoomFlipY
// 作用：创建一个带有缩放的Y轴反转切换的动画
// 参数1：过渡动作的持续时间
// 参数2：切换的目标场景的对象
// 参数3：反转类型的枚举变量 左右上下
// reScene=CCTransitionZoomFlipY::create(t, s, kOrientationDownOver);
// CCDirector::sharedDirector()->replaceScene(reScene);
// CCTransitionZoomFlipAngular
// 作用：创建一个带有缩放 ，反转角切换的动画
// 参数1：过渡动作的持续时间
// 参数2：切换的目标场景的对象
// 参数3：反转类型的枚举变量 左右上下
// reScene=CCTransitionZoomFlipAngular::create(t, s, kOrientationRightOver);
// CCDirector::sharedDirector()->replaceScene(reScene);
// CCTransitionShrinkGrow
// 创建一个放缩交替的过渡动画
// 参数1：过渡动作的持续时间
// 参数2：切换的目标场景的对象
// reScene = CCTransitionShrinkGrow::create(t, s);
// CCDirector::sharedDirector()->replaceScene(reScene);
// CCTransitionRotoZoom
// 创建一个旋转放缩交替的过渡动画
// 参数1：过渡动作的持续时间
// 参数2：切换的目标场景的对象
// reScene = CCTransitionRotoZoom::create(t, s);
// CCDirector::sharedDirector()->replaceScene(reScene);
// CCTransitionMoveInL
// 作用：创建一个从左边推入覆盖的过渡动画
// 参数1：过渡动作的持续时间
// 参数2：切换的目标场景的对象
// reScene = CCTransitionMoveInL::create(t, s);
// CCDirector::sharedDirector()->replaceScene(reScene);
// CCTransitionMoveInR
// 作用：创建一个从右边推入覆盖的过渡动画
// 参数1：过渡动作的持续时间
// 参数2：切换的目标场景的对象
// reScene = CCTransitionMoveInR::create(t, s);
// CCDirector::sharedDirector()->replaceScene(reScene);
// CCTransitionMoveInB
// 作用：创建一个从下边推入覆盖的过渡动画
// 参数1：过渡动作的持续时间
// 参数2：切换的目标场景的对象
// reScene = CCTransitionMoveInB::create(t, s);
// CCDirector::sharedDirector()->replaceScene(reScene);
// CCTransitionMoveInT
// 作用：创建一个从上边推入覆盖的过渡动画
// 参数1：过渡动作的持续时间
// 参数2：切换的目标场景的对象
// reScene = CCTransitionMoveInT::create(t, s);
// CCDirector::sharedDirector()->replaceScene(reScene);
// CCTransitionSlideInL
// 作用：创建一个从左侧推入并顶出旧场景的过渡动画
// 参数1：过渡动作的持续时间
// 参数2：切换的目标场景的对象
// reScene =CCTransitionSlideInL::create(t, s);
// CCDirector::sharedDirector()->replaceScene(reScene);
// CCTransitionSlideInR
// 作用：创建一个从右侧推入并顶出旧场景的过渡动画
// 参数1：过渡动作的持续时间
// 参数2：切换的目标场景的对象
// reScene =CCTransitionSlideInR::create(t, s);
// CCDirector::sharedDirector()->replaceScene(reScene);
// CCTransitionSlideInT
// 作用：创建一个从顶部推入并顶出旧场景的过渡动画
// 参数1：过渡动作的持续时间
// 参数2：切换的目标场景的对象
// reScene =CCTransitionSlideInT::create(t, s);
// CCDirector::sharedDirector()->replaceScene(reScene);
// CCTransitionSlideInB
// 作用：创建一个从下部推入并顶出旧场景的过渡动画
// 参数1：过渡动作的持续时间
// 参数2：切换的目标场景的对象
//reScene = CCTransitionSlideInB::create(t, s);
//CCDirector::sharedDirector()->replaceScene(reScene);
}
//触摸移动
void PackagingClass::TouchMoveSprite(Touch *touch, Sprite* Sprites)
{
Vec2 Temp = touch->getLocation() - touch->getPreviousLocation();//当前的点减上次的点
//Sprites->setPosition(Vec2(Sprites->getPosition().x, Sprites->getPosition().y + Temp.y));
//Sprites->setPosition(Vec2(Sprites->getPosition().x + Temp.x, Sprites->getPosition().y));
Sprites->setPosition(Vec2(Sprites->getPosition().x + Temp.x, Sprites->getPosition().y + Temp.y));
}
void PackagingClass::TouchMoveSprite(Touch *touch, Sprite* Sprites, void *null)
{
Vec2 Temp = touch->getLocation() - touch->getPreviousLocation();//当前的点减上次的点
Sprites->setPosition(Vec2(Sprites->getPosition().x + Temp.x, Sprites->getPosition().y + Temp.y));
for (int i = 0; i < 11; i++)
{
for (int j = 0; j < 11; j++)
{
if (Sprites->getPosition().x >= m_StandardPos[i][j].x - 25.0f && Sprites->getPosition().x <= m_StandardPos[i][j].x + 25.0f &&
Sprites->getPosition().y >= m_StandardPos[i][j].y - 25.0f && Sprites->getPosition().y <= m_StandardPos[i][j].y + 25.0f)
{
Sprites->setPosition(m_StandardPos[i][j]);
return;
}
}
}
}
//Menu菜单
Menu *PackagingClass::CreateMenu()
{
Menu *menu = Menu::create();
return menu;
}
//用某个节点创建菜单项
MenuItemLabel *PackagingClass::InsertMenuItemLabel(Node *node)
{
MenuItemLabel *menuItemLabel = MenuItemLabel::create(node);
//menuItemLabel->setPosition(Vec2(0, 0));
//menuItemLabel->setName("123");
//menuItemLabel->setTag(666);
return menuItemLabel;
}
void PackagingClass::RegisterMenuItemLabel(MenuItemLabel* MenuItemLabel, MENUITEMLABEL_FUNCTION MenuItemCallback)
{
MenuItemLabel->setCallback(MenuItemCallback);
//注册方法2
//MenuItemLabel *menuItemLabel = MenuItemLabel::create(label, CC_CALLBACK_1(GameLogScene::MenuCallback, this));
//menuItemLabel->setCallback(CC_CALLBACK_1(GameLogScene::MenuCallback, this));
}
//布局
Position *PackagingClass::OverallArrangemet(int Number)
{
Position *Arr = new Position[Number];
memset(Arr, 0, sizeof(Position) * Number);
for (int i = 0; i < Number; i++)
{
Arr[i].X = 0;
Arr[i].Y = 0;
std::cout << Arr[i].X << " " << Arr[i].Y << std::endl;
}
//死的
int Up_Y = 1240;
int Down_Y = 280;
//活的
int DisPlayWidth = 750;
int DIsplayHeight = 1335;
//可调
int Up_YOffset = 100;
int Down_YOffset = 100;
//求得
int Up_Down_AddOffset = 0;
Up_Down_AddOffset = Up_Y - (Down_Y + (Up_YOffset + Down_YOffset));
//活的
int DisPlayLeftX = 60;
int DisPlayRightX = 690;
//最上面的和最下面的的可放总位置的长度
int RightUp = Up_Y - Up_YOffset;
int RightDown = Down_Y + Down_YOffset;
int RightUpAddDown = RightUp - RightDown;
//偶数刚刚好
if (Number % 2 == 0)
{
//中间那一个
int Center = (Number / 2) + 1;
//右边放的总个数
//减去最上面的一个就是右边可以放的总数
int RightCount = Center - 2;
//右边可以放
if (RightCount != 0)
{
//直接放的顶端
Arr[0].X = DisPlayWidth / 2;
Arr[0].Y = Up_Y;
//人数为四个的时候
if (RightCount == 1)
{
Arr[1].X = DisPlayRightX;
Arr[1].Y = RightUp - RightUpAddDown / 2;
Arr[Center - 1].X = DisPlayWidth / 2;
Arr[Center - 1].Y = Down_Y;
Arr[3].X = DisPlayLeftX;
Arr[3].Y = RightUp - RightUpAddDown / 2;
}
else//人数大于四个的时候
{
//Right
int RightOneByOneOffset = RightUpAddDown / (RightCount - 1);
for (int i = 0; i < RightCount; i++)
{
Arr[i + 1].X = DisPlayRightX;
Arr[i + 1].Y = RightUp;
RightUp -= RightOneByOneOffset;
}
Arr[Center - 1].X = DisPlayWidth / 2;
Arr[Center - 1].Y = Down_Y;
//Left
int temp = 2;
for (int i = Center; i < Number; i++)
{
Arr[i].X = DisPlayLeftX;
Arr[i].Y = Arr[i - temp].Y;
temp += 2;
}
}
}
else
{
Arr[0].X = DisPlayWidth / 2;
Arr[0].Y = Up_Y;
Arr[Center - 1].X = DisPlayWidth / 2;
Arr[Center - 1].Y = Down_Y;
}
for (int i = 0; i < Number; i++)
{
std::cout << Arr[i].X << " " << Arr[i].Y << std::endl;
}
}
else
{
//中间那一个
int Center = (Number + 1) / 2;
//总数只有三个时,从右边开始只放一个
if (Center - 1 == 1)
{
Arr[0].X = DisPlayRightX;
Arr[0].Y = RightUp - RightUpAddDown / 2;
Arr[1].X = DisPlayWidth / 2;
Arr[1].Y = Down_Y;
Arr[2].X = DisPlayLeftX;
Arr[2].Y = Arr[0].Y;
}
else
{
Arr[Center - 1].X = DisPlayWidth / 2;
Arr[Center - 1].Y = Down_Y;
int SideCount = (Number - 1) / 2;
int RightOneByOneOffset = RightUpAddDown / (SideCount - 1);
for (int i = 0; i < Center - 1; i++)
{
Arr[i].X = DisPlayRightX;
Arr[i].Y = RightUp;
RightUp -= RightOneByOneOffset;
}
//Left
int temp = 2;
for (int i = Center; i < Number; i++)
{
Arr[i].X = DisPlayLeftX;
Arr[i].Y = Arr[i - temp].Y;
temp += 2;
}
}
}
return Arr;
}
//单子弹功能
void PackagingClass::Push_Back(Sprite *Sprites)
{
m_VectorBullet.push_back(Sprites);
}
void PackagingClass::UpdataBullet_Y_(Node *This, float Max_Y, float Speed)//当前节点,最大的Y,速度
{
for (std::vector<Sprite*>::iterator it = m_VectorBullet.begin(); it != m_VectorBullet.end();)
{
if (!m_VectorBullet.empty())
{
(*it)->setPosition(Vec2((*it)->getPosition().x, (*it)->getPosition().y + Speed));
if ((*it)->getPosition().y >= Max_Y)
{
This->removeChild(*it);
it = m_VectorBullet.erase(it);
}
else//这里和放到end()后面有点区别"及在释放范围条件外不会出现断言"
{
it++;
}
}
}
}
void PackagingClass::Delete_Bullet()
{
m_VectorBullet.clear();
}
void PackagingClass::Delete_OneBullet(Node *This, std::vector<Sprite*>::iterator &it_)
{
//this->removeChild((*it_));
//it_ = (*m_Obj->Return_Enemy_it()).erase(it_);
//循环遍历时,在判断语句中加入这句,it++不变,就在end();的后面就是,不用else
//std::vector<Sprite*>::iterator it_ 和std::vector<Sprite*> it 是不一样的,
}
std::vector<Sprite*> *PackagingClass::Get_Bullet_it()
{
return &m_VectorBullet;
}
//单向基本的碰撞释放
void PackagingClass::Release_One_AirAndBulletCrash(Node *This)
{
bool CrashState = false;
for (std::vector<Sprite*>::iterator it = m_VectorBullet.begin(); it != m_VectorBullet.end();)
{
for (std::vector<Sprite*>::iterator it_ = m_VectorEnemy.begin(); it_ != m_VectorEnemy.end();)
{
if ((*it_)->boundingBox().intersectsRect((*it)->boundingBox()))
{
This->removeChild((*it_));
it_ = m_VectorEnemy.erase(it_);
CrashState = true;
break;
}
else
{
it_++;
}
}
if (CrashState)
{
This->removeChild((*it));
it = m_VectorBullet.erase(it);
CrashState = false;
}
else
{
it++;
}
}
}
//================================================================共同的敌机功能
void PackagingClass::EnemyDirPush_Back(Sprite *Sprites)
{
m_VectorEnemy.push_back(Sprites);
}
void PackagingClass::UpdataEnemyDir_Y_(Node *This, float X, float Y, float Max_Y, float Speed)
{
for (std::vector<Sprite*>::iterator it = m_VectorEnemy.begin(); it != m_VectorEnemy.end();)
{
if (!m_VectorEnemy.empty())
{
(*it)->setPosition(Vec2((*it)->getPosition().x, (*it)->getPosition().y - Speed));
if ((*it)->getPosition().y <= Max_Y)
{
This->removeChild(*it);
it = m_VectorEnemy.erase(it);
}
else//这里和放到end()后面有点区别"及在释放范围条件外不会出现断言"
{
it++;
}
}
}
}
void PackagingClass::Delete_EnemyDir()
{
m_VectorEnemy.clear();
}
void PackagingClass::Delete_OneEnemy(Node *This, std::vector<Sprite*>::iterator &it_)
{
//this->removeChild((*it_));
//it_ = (*m_Obj->Return_Enemy_it()).erase(it_);
//循环遍历时,在判断语句中加入这句,it++不变,就在end();的后面就是,最好用else"及在释放范围外不会出现断言"
}
std::vector<Sprite*> *PackagingClass::Get_Enemy_it()
{
return &m_VectorEnemy;
}
//双管子弹
void PackagingClass::Push_Back(Sprite *Sprites_One, Sprite *Sprite_Two)
{
assert(Sprites_One);
assert(Sprite_Two);
m_VectorBullet_One.push_back(Sprites_One);
m_VectorBullet_Two.push_back(Sprite_Two);
}
void PackagingClass::UpdataDoubleBullet_Y_(Node *This, float Max_Y, float Speed)//当前节点,最大的Y,速度
{
for (std::vector<Sprite*>::iterator it = m_VectorBullet_One.begin(); it != m_VectorBullet_One.end();)
{
if (!m_VectorBullet_One.empty())
{
(*it)->setPosition(Vec2((*it)->getPosition().x, (*it)->getPosition().y + Speed));
if ((*it)->getPosition().y >= Max_Y)
{
This->removeChild(*it);
it = m_VectorBullet_One.erase(it);
}
else//这里和放到end()后面有点区别"及在释放范围条件外不会出现断言"
{
it++;
}
}
}
for (std::vector<Sprite*>::iterator it = m_VectorBullet_Two.begin(); it != m_VectorBullet_Two.end();)
{
if (!m_VectorBullet_Two.empty())
{
(*it)->setPosition(Vec2((*it)->getPosition().x, (*it)->getPosition().y + Speed));
if ((*it)->getPosition().y >= Max_Y)
{
This->removeChild(*it);
it = m_VectorBullet_Two.erase(it);
}
else//这里和放到end()后面有点区别"及在释放范围条件外不会出现断言"
{
it++;
}
}
}
}
void PackagingClass::Delete_DoubleBullet()//删除整个vector
{
m_VectorBullet_One.clear();
m_VectorBullet_Two.clear();
}
std::vector<Sprite*> *PackagingClass::Get_Bullet_itOne()
{
return &m_VectorBullet_One;
}
std::vector<Sprite*> *PackagingClass::Get_Bullet_itTwo()
{
return &m_VectorBullet_Two;
}
//双管子弹的碰撞释放
void PackagingClass::Release_Double_AirAndBulletCrash(Node *This)
{
bool CrashState = false;
for (std::vector<Sprite*>::iterator it = m_VectorBullet_One.begin(); it != m_VectorBullet_One.end();)
{
for (std::vector<Sprite*>::iterator it_ = m_VectorEnemy.begin(); it_ != m_VectorEnemy.end();)
{
if ((*it_)->boundingBox().intersectsRect((*it)->boundingBox()))
{
This->removeChild((*it_));
it_ = m_VectorEnemy.erase(it_);
CrashState = true;
break;
}
else
{
it_++;
}
}
if (CrashState)
{
This->removeChild((*it));
it = m_VectorBullet_One.erase(it);
CrashState = false;
}
else
{
it++;
}
}
bool CrashStates = false;
for (std::vector<Sprite*>::iterator it = m_VectorBullet_Two.begin(); it != m_VectorBullet_Two.end();)
{
for (std::vector<Sprite*>::iterator it_ = m_VectorEnemy.begin(); it_ != m_VectorEnemy.end();)
{
if ((*it_)->boundingBox().intersectsRect((*it)->boundingBox()))
{
This->removeChild((*it_));
it_ = m_VectorEnemy.erase(it_);
CrashStates = true;
break;
}
else
{
it_++;
}
}
if (CrashStates)
{
This->removeChild((*it));
it = m_VectorBullet_Two.erase(it);
CrashStates = false;
}
else
{
it++;
}
}
}
//poker 洗牌
void PackagingClass::InitShuffle()
{
srand(GetTickCount());
//王
m_Poker[52].PokerColor = 1;//小王
m_Poker[52].CurState = 1;
m_Poker[52].Poker = 15;
m_Poker[53].PokerColor = 2;//大王
m_Poker[53].CurState = 1;
m_Poker[53].Poker = 15;
int Color = 1;
int Temp = 0;
for (int i = 0; i < 52; i += 4)
{
Color = 1;
for (int j = 0; j < 4; j++)
{
m_Poker[i + j].Poker = Temp + 2;
m_Poker[i + j].CurState = 1;
m_Poker[i + j].PokerColor = Color;
Color++;
}
Temp++;
}
}
//发牌
void PackagingClass::Deal()
{
int TempRand = 0;
for (int i = 0; i < 17; i++)
{
do
{
TempRand = rand() % 54;
if (m_Poker[TempRand].CurState == 1)
{
m_UserLeft[i].PokerColor = m_Poker[TempRand].PokerColor;
m_UserLeft[i].Poker = m_Poker[TempRand].Poker;
}
} while (m_Poker[TempRand].CurState == 0);
m_Poker[TempRand].CurState = 0;
}
TempRand = 0;
for (int i = 0; i < 17; i++)
{
do
{
TempRand = rand() % 54;
if (m_Poker[TempRand].CurState == 1)
{
m_MainUser[i].PokerColor = m_Poker[TempRand].PokerColor;
m_MainUser[i].Poker = m_Poker[TempRand].Poker;
}
} while (m_Poker[TempRand].CurState == 0);
m_Poker[TempRand].CurState = 0;
}
TempRand = 0;
for (int i = 0; i < 17; i++)
{
do
{
TempRand = rand() % 54;
if (m_Poker[TempRand].CurState == 1)
{
m_UserRight[i].PokerColor = m_Poker[TempRand].PokerColor;
m_UserRight[i].Poker = m_Poker[TempRand].Poker;
}
} while (m_Poker[TempRand].CurState == 0);
m_Poker[TempRand].CurState = 0;
}
int var = 0;
}
//牌牌排序
void PackagingClass::User_Sort(User *MainUser, int Len)
{
for (int i = 0; i < Len - 1; i++)
{
for (int j = i + 1; j < Len; j++)
{
if (MainUser[i].Poker > MainUser[j].Poker)
{
User Temp = MainUser[i];
MainUser[i] = MainUser[j];
MainUser[j] = Temp;
}
}
}
}
//加载牌牌
void PackagingClass::LoadPoker()
{
// A 1
// B 2
// C 3
// D 4
for (int i = 0; i < 17; i++)
{
switch (m_MainUser[i].PokerColor)
{
case 1:
{
char Buf[64] = { 0 };
sprintf_s(Buf, "Poker/%dA.png", m_MainUser[i].Poker);
Sprite *PokerSprite = CreateSprite(Buf);
}; break;
case 2:
{
char Buf[64] = { 0 };
sprintf_s(Buf, "Poker/%dB.png", m_MainUser[i].Poker);
Sprite *PokerSprite = CreateSprite(Buf);
}; break;
case 3:
{
char Buf[64] = { 0 };
sprintf_s(Buf, "Poker/%dC.png", m_MainUser[i].Poker);
Sprite *PokerSprite = CreateSprite(Buf);
}; break;
case 4:
{
char Buf[64] = { 0 };
sprintf_s(Buf, "Poker/%dD.png", m_MainUser[i].Poker);
Sprite *PokerSprite = CreateSprite(Buf);
}; break;
}
switch (m_UserLeft[i].PokerColor)
{
case 1:
{
char Buf[64] = { 0 };
sprintf_s(Buf, "Poker/%dA.png", m_UserLeft[i].Poker);
Sprite *PokerSprite = CreateSprite(Buf);
}; break;
case 2:
{
char Buf[64] = { 0 };
sprintf_s(Buf, "Poker/%dB.png", m_UserLeft[i].Poker);
Sprite *PokerSprite = CreateSprite(Buf);
}; break;
case 3:
{
char Buf[64] = { 0 };
sprintf_s(Buf, "Poker/%dC.png", m_UserLeft[i].Poker);
Sprite *PokerSprite = CreateSprite(Buf);
}; break;
case 4:
{
char Buf[64] = { 0 };
sprintf_s(Buf, "Poker/%dD.png", m_UserLeft[i].Poker);
Sprite *PokerSprite = CreateSprite(Buf);
}; break;
}
switch (m_UserRight[i].PokerColor)
{
case 1:
{
char Buf[64] = { 0 };
sprintf_s(Buf, "Poker/%dA.png", m_UserRight[i].Poker);
Sprite *PokerSprite = CreateSprite(Buf);
}; break;
case 2:
{
char Buf[64] = { 0 };
sprintf_s(Buf, "Poker/%dB.png", m_UserRight[i].Poker);
Sprite *PokerSprite = CreateSprite(Buf);
}; break;
case 3:
{
char Buf[64] = { 0 };
sprintf_s(Buf, "Poker/%dC.png", m_UserRight[i].Poker);
Sprite *PokerSprite = CreateSprite(Buf);
}; break;
case 4:
{
char Buf[64] = { 0 };
sprintf_s(Buf, "Poker/%dD.png", m_UserRight[i].Poker);
Sprite *PokerSprite = CreateSprite(Buf);
}; break;
}
}
}
//显示牌牌
void PackagingClass::ShowPoker(Node *This)
{
int W = 35;
int Width = 150;
int MainY = 100;
for (int i = 0; i < 17; i++)
{
switch (m_MainUser[i].PokerColor)
{
case 1:
{
char Buf[64] = { 0 };
sprintf_s(Buf, "Poker/%dA.png", m_MainUser[i].Poker);
Sprite *sprite = GetSprite(Buf);
sprite->setPosition(Vec2(Width + W * (i * 1), MainY));
This->addChild(sprite);
}; break;
case 2:
{
char Buf[64] = { 0 };
sprintf_s(Buf, "Poker/%dB.png", m_MainUser[i].Poker);
Sprite *sprite = GetSprite(Buf);
sprite->setPosition(Vec2(Width + W * (i * 1), MainY));
This->addChild(sprite);
}; break;
case 3:
{
char Buf[64] = { 0 };
sprintf_s(Buf, "Poker/%dC.png", m_MainUser[i].Poker);
Sprite *sprite = GetSprite(Buf);
sprite->setPosition(Vec2(Width + W * (i * 1), MainY));
This->addChild(sprite);
}; break;
case 4:
{
char Buf[64] = { 0 };
sprintf_s(Buf, "Poker/%dD.png", m_MainUser[i].Poker);
Sprite *sprite = GetSprite(Buf);
sprite->setPosition(Vec2(Width + W * (i * 1), MainY));
This->addChild(sprite);
}; break;
}
}
}
//返回牌牌
User *PackagingClass::GetUserMainUser()
{
return m_MainUser;
}
User *PackagingClass::GetUserLeft()
{
return m_UserLeft;
}
User *PackagingClass::GetUserRight()
{
return m_UserRight;
}
//出牌牌后牌牌再次排序后的位置更新
void PackagingClass::OutPokerPostionUpdata(User *Poker__, int Len, int Width, int W, int MainY, Node *This)
{
int SUBLen = 0;//出掉的牌
for (int i = 0; i < Len; i++)
{
if (Poker__[i].CurState != 1)//剩下的牌牌
{
switch (Poker__[i].PokerColor)
{
case 1:
{
char Buf[64] = { 0 };
sprintf_s(Buf, "Poker/%dA.png", Poker__[i].Poker);
Sprite *sprite = GetSprite(Buf);
sprite->setPosition(Vec2(Width + (W * i), MainY));
}; break;
case 2:
{
char Buf[64] = { 0 };
sprintf_s(Buf, "Poker/%dB.png", Poker__[i].Poker);
Sprite *sprite = GetSprite(Buf);
sprite->setPosition(Vec2(Width + (W * i), MainY));
}; break;
case 3:
{
char Buf[64] = { 0 };
sprintf_s(Buf, "Poker/%dC.png", Poker__[i].Poker);
Sprite *sprite = GetSprite(Buf);
sprite->setPosition(Vec2(Width + (W * i), MainY));
}; break;
case 4:
{
char Buf[64] = { 0 };
sprintf_s(Buf, "Poker/%dD.png", Poker__[i].Poker);
Sprite *sprite = GetSprite(Buf);
sprite->setPosition(Vec2(Width + (W * i), MainY));
}; break;
}
}
else//出掉的牌牌
{
switch (Poker__[i].PokerColor)
{
case 1:
{
char Buf[64] = { 0 };
sprintf_s(Buf, "Poker/%dA.png", Poker__[i].Poker);
Sprite *sprite = GetSprite(Buf);
This->removeChild(sprite);
SUBLen++;
}; break;
case 2:
{
char Buf[64] = { 0 };
sprintf_s(Buf, "Poker/%dB.png", Poker__[i].Poker);
Sprite *sprite = GetSprite(Buf);
This->removeChild(sprite);
SUBLen++;
}; break;
case 3:
{
char Buf[64] = { 0 };
sprintf_s(Buf, "Poker/%dC.png", Poker__[i].Poker);
Sprite *sprite = GetSprite(Buf);
This->removeChild(sprite);
SUBLen++;
}; break;
case 4:
{
char Buf[64] = { 0 };
sprintf_s(Buf, "Poker/%dD.png", Poker__[i].Poker);
Sprite *sprite = GetSprite(Buf);
This->removeChild(sprite);
SUBLen++;
}; break;
}
}
}
for (int i = 0; i < Len; i++)
{
if (Poker__[i].CurState == 1)
{
for (int j = i + 1; j < Len; j++)
{
if (Poker__[j].CurState == 0)
{
User Temp = Poker__[j];
Poker__[j] = Poker__[i];
Poker__[i] = Temp;
break;
}
}
}
}
float Offset = 0;
float Starting = Width;//第一张的坐标
float Ending = Width + (W * (Len - SUBLen - 1));//最后一张的坐标
Starting -= 63;//精灵的宽的一半
Ending += 63;//精灵的宽的一半
Offset = (Starting + (800 - Ending)) / 2;//剩下的没有被牌所占的空间的一半
Width = Offset + (Width / 2);//牌的偏移量
for (int i = 0; i < Len - SUBLen; i++)
{
if (Poker__[i].CurState != 1)//剩下的牌牌
{
switch (Poker__[i].PokerColor)
{
case 1:
{
char Buf[64] = { 0 };
sprintf_s(Buf, "Poker/%dA.png", Poker__[i].Poker);
Sprite *sprite = GetSprite(Buf);
sprite->setPosition(Vec2(Width + (W * i), MainY));
}; break;
case 2:
{
char Buf[64] = { 0 };
sprintf_s(Buf, "Poker/%dB.png", Poker__[i].Poker);
Sprite *sprite = GetSprite(Buf);
sprite->setPosition(Vec2(Width + (W * i), MainY));
}; break;
case 3:
{
char Buf[64] = { 0 };
sprintf_s(Buf, "Poker/%dC.png", Poker__[i].Poker);
Sprite *sprite = GetSprite(Buf);
sprite->setPosition(Vec2(Width + (W * i), MainY));
}; break;
case 4:
{
char Buf[64] = { 0 };
sprintf_s(Buf, "Poker/%dD.png", Poker__[i].Poker);
Sprite *sprite = GetSprite(Buf);
sprite->setPosition(Vec2(Width + (W * i), MainY));
}; break;
}
}
}
}
//加载左边玩家的牌牌
void PackagingClass::OutPokerLeftBackgroundUpdata(User *Poker_, int Len, Texture2D *Texture, Node *This)
{
float X = 100.0f;
float Y = 20.0f;
float Height = 200.0f;
for (int i = 0; i < Len; i++)
{
Sprite *Temp = CreateTextureSprite(Texture);
Temp->setRotation(90.0f);
Temp->setScale(0.5f);
Temp->setPosition(Vec2(X, Height + (i * Y)));
This->addChild(Temp);
}
}
//加载右边玩家的牌牌
void PackagingClass::OutPokerRightBackgroundUpdata(User *Poker_, int Len, Texture2D *Texture, Node *This)
{
float X = 700.0f;
float Y = 20.0f;
float Height = 200.0f;
for (int i = 0; i < Len; i++)
{
Sprite *Temp = CreateTextureSprite(Texture);
Temp->setRotation(90.0f);
Temp->setScale(0.5f);
Temp->setPosition(Vec2(X, Height + (i * Y)));
This->addChild(Temp);
}
}
//五子棋
DrawNode* PackagingClass::CreateGobangMap()
{
DrawNode *drawNode = DrawNode::create(3.5f);
int Y = 550;
int X = 50;
for (int i = 0; i < 11; i++)
{
drawNode->drawLine(Vec2(50, Y), Vec2(550, Y), Color4F::BLACK);
drawNode->drawLine(Vec2(X, 552), Vec2(X, 48), Color4F::BLACK);
Y -= 50;
X += 50;
}
return drawNode;
}
//标准坐标
void PackagingClass::StandardPos(Sprite *Sprites)
{
float X = 50.0f;
float Y = 550.0f;
for (int i = 0; i < 11; i++)
{
for (int j = 0; j < 11; j++)
{
m_StandardPos[i][j] = Vec2(X * (j + 1), Y); //得到每一个格子的标准坐标
}
Y -= 50.0f;
}
for (int i = 0; i < 11; i++)
{
for (int j = 0; j < 11; j++)
{
if (Sprites->getPosition().x >= m_StandardPos[i][j].x - 25.0f && Sprites->getPosition().x <= m_StandardPos[i][j].x + 25.0f &&
Sprites->getPosition().y >= m_StandardPos[i][j].y - 25.0f && Sprites->getPosition().y <= m_StandardPos[i][j].y + 25.0f)
{
Sprites->setPosition(m_StandardPos[i][j]);
return;
}
}
}
}
//=======================================================================
//注册每一帧调用：void class::Update(float Time);
void PackagingClass::RegisterEachFrameCall(Node *node)
{
if (node)
{
node->scheduleUpdate();
}
return;
}
//注册鼠标事件
void PackagingClass::RegisterMouseEvent(Node *node,
MOUSEEVENTFUNCTION MouseDown,
MOUSEEVENTFUNCTION MouseUp,
MOUSEEVENTFUNCTION MouseMove,
MOUSEEVENTFUNCTION MouseScroll)
{
if (node && MouseDown && MouseUp && MouseMove && MouseScroll)
{
MONITORBING MonitorBing;
LPMONITORBING LPMonitorBing = &MonitorBing;
LPMonitorBing->Dispatcher = Director::getInstance()->getEventDispatcher();
LPMonitorBing->ListenerMouse = EventListenerMouse::create();
//这里只能用兰姆达
LPMonitorBing->ListenerMouse->onMouseDown = [=](Event *event)
{
PackagingClass::_OnMouseDown(MouseDown, event);
};
LPMonitorBing->ListenerMouse->onMouseUp = [=](Event *event)
{
PackagingClass::_OnMouseUp(MouseUp, event);
};
LPMonitorBing->ListenerMouse->onMouseMove = [=](Event *event)
{
PackagingClass::_OnMouseMove(MouseMove, event);
};
//LPMonitorBing->ListenerMouse->onMouseMove = OnMouseMove;
LPMonitorBing->ListenerMouse->onMouseScroll = [=](Event *event)
{
PackagingClass::_OnMouseScroll(MouseScroll, event);
};
LPMonitorBing->Dispatcher->addEventListenerWithSceneGraphPriority(LPMonitorBing->ListenerMouse, node);
}
return;
}
void PackagingClass::RegisterMouseEvent(Node *node,
MOUSEEVENTFUNCTION MouseDown,
MOUSEEVENTFUNCTION MouseUp,
MOUSEEVENTFUNCTION MouseMove)
{
if (node && MouseDown && MouseUp && MouseMove)
{
MONITORBING MonitorBing;
LPMONITORBING LPMonitorBing = &MonitorBing;
LPMonitorBing->Dispatcher = Director::getInstance()->getEventDispatcher();
LPMonitorBing->ListenerMouse = EventListenerMouse::create();
//这里只能用兰姆达
LPMonitorBing->ListenerMouse->onMouseDown = [=](Event *event)
{
//EventMouse *M = (EventMouse*)event;
//M->getCursorX();
//FunctionCallBack(event);
PackagingClass::_OnMouseDown(MouseDown, event);
};
LPMonitorBing->ListenerMouse->onMouseUp = [=](Event *event)
{
//EventMouse *M = (EventMouse*)event;
//M->getCursorX();
//FunctionCallBack(event);
PackagingClass::_OnMouseUp(MouseUp, event);
};
LPMonitorBing->ListenerMouse->onMouseMove = [=](Event *event)
{
//EventMouse *M = (EventMouse*)event;
//M->getCursorX();
//FunctionCallBack(event);
PackagingClass::_OnMouseMove(MouseMove, event);
};
LPMonitorBing->Dispatcher->addEventListenerWithSceneGraphPriority(LPMonitorBing->ListenerMouse, node);
}
return;
}
//注册按键事件
void PackagingClass::RegisterKeyEvent(Node *node,
KEYEVENTFUNCTION OnKeyDown,
KEYEVENTFUNCTION OnKeyUp)
{
if (OnKeyDown && OnKeyUp)
{
EventDispatcher *Dispatcher = Director::getInstance()->getEventDispatcher();
EventListenerKeyboard *KeyListener = EventListenerKeyboard::create();
//KeyListener->onKeyPressed = CC_CALLBACK_2(HelloWorld::onKeyPressed, this);//按下
//KeyListener->onKeyReleased = CC_CALLBACK_2(HelloWorld::onKeyReleased, this);//抬起
KeyListener->onKeyPressed = [=](EventKeyboard::KeyCode KeyCode, Event *event)
{
PackagingClass::_OnKeyPressed(OnKeyDown, KeyCode, event);
};
KeyListener->onKeyReleased = [=](EventKeyboard::KeyCode KeyCode, Event *event)
{
PackagingClass::_OnKeyReleased(OnKeyUp, KeyCode, event);
};
Dispatcher->addEventListenerWithSceneGraphPriority(KeyListener, node);
}
return;
}
//注册触摸单点事件
void PackagingClass::RegisterTouchEvent(Node *node,
TOUCHEVENTFUNCTION OnTouchBegin,
TOUCHEVENT_FUNCTION OnTouchMove,
TOUCHEVENT_FUNCTION OnTouchEnd)
{
if (OnTouchBegin && OnTouchMove && OnTouchEnd)
{
//auto touchListener = EventListenerTouchOneByOne::create();
//touchListener->onTouchBegan = CC_CALLBACK_2(HelloWorld::onTouchBegan, this);
//touchListener->onTouchMoved = CC_CALLBACK_2(HelloWorld::onTouchMoved, this);
//touchListener->onTouchEnded = CC_CALLBACK_2(HelloWorld::onTouchEnded, this);
//touchListener->onTouchCancelled = CC_CALLBACK_2(HelloWorld::onTouchCancelled, this);
//Director::getInstance()->getEventDispatcher()->addEventListenerWithSceneGraphPriority(touchListener, this);
EventDispatcher *Dispatcher = Director::getInstance()->getEventDispatcher();
EventListenerTouchOneByOne *TouchListener = EventListenerTouchOneByOne::create();
//可以直接赋值,是可以的
//TouchListener->onTouchBegan = TouchBegin;
//TouchListener->onTouchBegan = [ = ](Touch *touch, Event *event)->bool
//{
// TouchBegin(touch,event);
// return true;
//};
//TouchListener->onTouchMoved = [=](Touch *touch, Event *event)
//{
// TouchMove(touch, event);
//};
//TouchListener->onTouchEnded = [=](Touch *touch, Event *event)
//{
// TouchEnd(touch, event);
//};
TouchListener->onTouchBegan = [=](Touch *touch, Event *event)->bool
{
return PackagingClass::_OnTouchBegin(OnTouchBegin, touch, event);
};
TouchListener->onTouchMoved = [=](Touch *touch, Event *event)
{
PackagingClass::_OnTouchMove(OnTouchMove, touch, event);
};
TouchListener->onTouchEnded = [=](Touch *touch, Event *event)
{
PackagingClass::_OnTouchEnd(OnTouchEnd, touch, event);
};
Director::getInstance()->getEventDispatcher()->addEventListenerWithSceneGraphPriority(TouchListener, node);
}
return;
}
void PackagingClass::RegisterTouchEvent(Node *node,
TOUCHEVENTFUNCTION OnTouchBegin,
TOUCHEVENT_FUNCTION OnTouchMove,
TOUCHEVENT_FUNCTION OnTouchEnd,
TOUCHEVENT_FUNCTION OnTouchCancelle)
{
if (OnTouchBegin && OnTouchMove && OnTouchEnd && OnTouchCancelle)
{
EventDispatcher *Dispatcher = Director::getInstance()->getEventDispatcher();
EventListenerTouchOneByOne *TouchListener = EventListenerTouchOneByOne::create();
TouchListener->onTouchBegan = [=](Touch *touch, Event *event)->bool
{
return PackagingClass::_OnTouchBegin(OnTouchBegin, touch, event);
};
TouchListener->onTouchMoved = [=](Touch *touch, Event *event)
{
PackagingClass::_OnTouchMove(OnTouchMove, touch, event);
};
TouchListener->onTouchEnded = [=](Touch *touch, Event *event)
{
PackagingClass::_OnTouchEnd(OnTouchEnd, touch, event);
};
//不知道有什么用
TouchListener->onTouchCancelled = [=](Touch *touch, Event *event)
{
PackagingClass::_OnTouchCancelle(OnTouchCancelle, touch, event);
};
Director::getInstance()->getEventDispatcher()->addEventListenerWithSceneGraphPriority(TouchListener, node);
}
return;
}
void PackagingClass::_OnMouseDown(MOUSEEVENTFUNCTION MouseDown, Event *event)
{
MouseDown(event);
}
void PackagingClass::_OnMouseUp(MOUSEEVENTFUNCTION MouseUp, Event *event)
{
MouseUp(event);
}
void PackagingClass::_OnMouseMove(MOUSEEVENTFUNCTION MouseMove, Event *event)
{
MouseMove(event);
}
void PackagingClass::_OnMouseScroll(MOUSEEVENTFUNCTION MouseScroll, Event *event)
{
MouseScroll(event);
}
void PackagingClass::_OnKeyPressed(KEYEVENTFUNCTION OnKeyDown, EventKeyboard::KeyCode KeyCode, Event *event)
{
OnKeyDown(KeyCode, event);
}
void PackagingClass::_OnKeyReleased(KEYEVENTFUNCTION OnKeyUp, EventKeyboard::KeyCode KeyCode, Event *event)
{
OnKeyUp(KeyCode, event);
}
bool PackagingClass::_OnTouchBegin(TOUCHEVENTFUNCTION OnTouchBegin, Touch *touch, Event *event)
{
return OnTouchBegin(touch, event);
}
void PackagingClass::_OnTouchMove(TOUCHEVENT_FUNCTION OnTouchMove, Touch *touch, Event *event)
{
OnTouchMove(touch, event);
}
void PackagingClass::_OnTouchEnd(TOUCHEVENT_FUNCTION OnTouchEnd, Touch *touch, Event *event)
{
OnTouchEnd(touch, event);
}
void PackagingClass::_OnTouchCancelle(TOUCHEVENT_FUNCTION OnTouchCancelle, Touch *touch, Event *event)
{
OnTouchCancelle(touch, event);
}