From 3eeae12c498d1a4dbe969462d2ba841f77ee3ccb Mon Sep 17 00:00:00 2001 From: Andrei Karas Date: Sun, 2 Jan 2011 01:48:38 +0200 Subject: Initial commit. This code based on mana client http://www.gitorious.org/mana/mana and my private repository. --- src/mumblemanager.cpp | 273 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 273 insertions(+) create mode 100644 src/mumblemanager.cpp (limited to 'src/mumblemanager.cpp') diff --git a/src/mumblemanager.cpp b/src/mumblemanager.cpp new file mode 100644 index 000000000..6586f9546 --- /dev/null +++ b/src/mumblemanager.cpp @@ -0,0 +1,273 @@ +/* Code taken from: http://mumble.sourceforge.net/Link */ + +#include "mumblemanager.h" + +#include "configuration.h" +#include "log.h" + +#include "utils/mathutils.h" + +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include + +#ifndef WIN32 +#include +#endif + +MumbleManager::MumbleManager() : + mLinkedMem(0) +{ + mMapBase[0] = mMapBase[1] = mMapBase[2] = 0.; + init(); +} + +MumbleManager::~MumbleManager() +{ + if (mLinkedMem) + { +#ifdef WIN32 + UnmapViewOfFile(mLinkedMem); +#elif defined __FreeBSD__ || defined __DragonFly__ +#else + munmap(mLinkedMem, sizeof(struct LinkedMem)); +#endif + mLinkedMem = 0; + } +} + +uint16_t MumbleManager::getMapId(std::string mapName) +{ + uint16_t res = 0; + if (mapName.size() != 5 || mapName[3] != '-') + { + res = getCrc16(mapName); + } + else + { + mapName = mapName.substr(0, 3) + mapName[4]; + res = atoi(mapName.c_str()); + } + return res; +} + +void MumbleManager::setMapBase(uint16_t mapid) +{ + mMapBase[0] = 10000. * (mapid & 0x1f); + mapid >>= 5; + mMapBase[1] = 1000. * (mapid & 0x3f); + mapid >>= 6; + mMapBase[2] = 10000. * (mapid & 0x1f); +} + +void MumbleManager::init() +{ +#if defined __FreeBSD__ || defined __DragonFly__ + return; +#endif + + if (mLinkedMem || !config.getBoolValue("enableMumble")) + return; + + logger->log1("MumbleManager::init"); +#ifdef WIN32 + HANDLE hMapObject = OpenFileMappingW(FILE_MAP_ALL_ACCESS, + FALSE, L"MumbleLink"); + if (hMapObject == NULL) + { + logger->log1("MumbleManager::init cant open MumbleLink"); + return; + } + + mLinkedMem = (LinkedMem *) MapViewOfFile(hMapObject, + FILE_MAP_ALL_ACCESS, 0, 0, sizeof(LinkedMem)); + + if (mLinkedMem == NULL) + { + CloseHandle(hMapObject); + hMapObject = NULL; + logger->log1("MumbleManager::init cant map MumbleLink"); + return; + } +#elif defined __FreeBSD__ || defined __DragonFly__ +#else + char memName[256]; + snprintf(memName, 256, "/MumbleLink.%d", getuid()); + + int shmfd = shm_open(memName, O_RDWR, S_IRUSR | S_IWUSR); + + if (shmfd < 0) + { + logger->log1("MumbleManager::init cant open shared memory MumbleLink"); + return; + } + + mLinkedMem = (LinkedMem *)(mmap(NULL, sizeof(struct LinkedMem), + PROT_READ | PROT_WRITE, MAP_SHARED, shmfd, 0)); + + if (mLinkedMem == (void *)(-1)) + { + mLinkedMem = NULL; + logger->log1("MumbleManager::init cant map MumbleLink"); + return; + } + +#endif + wcsncpy(mLinkedMemCache.name, L"Mana", 256); + wcsncpy(mLinkedMemCache.description, L"TheManaWorld Plugin", 2048); + mLinkedMemCache.uiVersion = 2; + + // Left handed coordinate system. + // X positive towards "left". + // Y positive towards "up". + // Z positive towards "into screen". + // + // 1 unit = 1 meter + + // Unit vector pointing out of the avatars eyes (here Front looks into scene). + /* no way to look "up", 2d */ + mLinkedMemCache.fAvatarFront[1] = 0.0f; + + // Unit vector pointing out of the top of the avatars head + // (here Top looks straight up). + /* no way to change this in tmw */ + mLinkedMemCache.fAvatarTop[0] = 0.0f; + mLinkedMemCache.fAvatarTop[1] = 1.0f; + mLinkedMemCache.fAvatarTop[2] = 0.0f; + + mLinkedMemCache.fCameraFront[0] = 0.0f; + mLinkedMemCache.fCameraFront[1] = 0.0f; + mLinkedMemCache.fCameraFront[2] = 1.0f; + + mLinkedMemCache.fCameraTop[0] = 0.0f; + mLinkedMemCache.fCameraTop[1] = 1.0f; + mLinkedMemCache.fCameraTop[2] = 0.0f; + + mLinkedMemCache.uiTick++; +} + +void MumbleManager::setPlayer(const std::string &userName) +{ + if (!mLinkedMem) + return; + + // Identifier which uniquely identifies a certain player in a context + // (e.g. the ingame Name). + mbstowcs(mLinkedMemCache.identity, userName.c_str(), 256); + mLinkedMemCache.uiTick ++; + memcpy(mLinkedMem, &mLinkedMemCache, sizeof(mLinkedMemCache)); +} + +void MumbleManager::setAction(int action) +{ + if (!mLinkedMem) + return; + + switch(action) + { + case 0: /* STAND */ + case 1: /* WALK */ + case 2: /* ATTACK */ + case 5: /* HURT */ + mLinkedMemCache.fAvatarPosition[1] = 1.5f; + break; + case 3: /* SIT */ + mLinkedMemCache.fAvatarPosition[1] = 1.0f; + break; + case 4: /* DEAD */ + default: + mLinkedMemCache.fAvatarPosition[1] = 0.0f; + break; + } + mLinkedMemCache.fAvatarPosition[1] += mMapBase[1]; + mLinkedMemCache.fCameraPosition[1] = mLinkedMemCache.fAvatarPosition[1]; + + mLinkedMemCache.uiTick++; + memcpy(mLinkedMem, &mLinkedMemCache, sizeof(mLinkedMemCache)); +} + +void MumbleManager::setPos(int tileX, int tileY, int direction) +{ + if (!mLinkedMem) + return; + + // Position of the avatar (here standing slightly off the origin) + // lm->fAvatarPosition + + /* tmw coordinates work exactly the other way round */ + mLinkedMemCache.fAvatarPosition[0] = tileX + mMapBase[0]; + mLinkedMemCache.fAvatarPosition[2] = tileY + mMapBase[2]; + + // Same as avatar but for the camera. + // lm->fCameraPosition, fCameraFront, fCameraTop + + // Same as avatar but for the camera. + mLinkedMemCache.fCameraPosition[0] = mLinkedMemCache.fAvatarPosition[0]; + mLinkedMemCache.fCameraPosition[2] = mLinkedMemCache.fAvatarPosition[2]; + + // Unit vector pointing out of the avatars eyes + // (here Front looks into scene). + switch(direction) + { + case 4: /* UP */ + mLinkedMemCache.fAvatarFront[0] = 0.0f; + mLinkedMemCache.fAvatarFront[2] = 1.0f; + break; + case 1: /* DOWN */ + mLinkedMemCache.fAvatarFront[0] = 0.0f; + mLinkedMemCache.fAvatarFront[2] = -1.0f; + break; + case 2: /* LEFT */ + mLinkedMemCache.fAvatarFront[0] = 1.0f; + mLinkedMemCache.fAvatarFront[2] = 0.0f; + break; + case 8: /* RIGHT */ + mLinkedMemCache.fAvatarFront[0] = -1.0f; + mLinkedMemCache.fAvatarFront[2] = 0.0f; + break; + default: + break; + } + + mLinkedMemCache.uiTick ++; + memcpy(mLinkedMem, &mLinkedMemCache, sizeof(mLinkedMemCache)); +} + +void MumbleManager::setMap(const std::string &mapName) +{ + if (!mLinkedMem) + return; + + // Context should be equal for players which should be able to hear each + // other positional and differ for those who shouldn't + // (e.g. it could contain the server+port and team) + + setMapBase(getMapId(mapName)); + setAction(0); /* update y coordinate */ +} + +void MumbleManager::setServer(const std::string &serverName) +{ + if (!mLinkedMem) + return; + + unsigned size = serverName.size(); + if (size > sizeof(mLinkedMemCache.context) - 1) + size = sizeof(mLinkedMemCache.context) - 1; + + memset(mLinkedMemCache.context, 0, sizeof(mLinkedMemCache.context)); + memcpy(mLinkedMemCache.context, serverName.c_str(), size); + mLinkedMemCache.context[size] = '\0'; + mLinkedMemCache.context_len = size; + mLinkedMemCache.uiTick ++; + memcpy(mLinkedMem, &mLinkedMemCache, sizeof(mLinkedMemCache)); +} -- cgit v1.2.3-70-g09d2