Initial commit

engines/darkseed/kofont.cpp

@@ -0,0 +1,311 @@
+/* ScummVM - Graphic Adventure Engine
+*
+* ScummVM is the legal property of its developers, whose names
+* are too numerous to list here. Please refer to the COPYRIGHT
+* file distributed with this source distribution.
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*
+*/
+
+#include "darkseed/darkseed.h"
+#include "darkseed/kofont.h"
+
+namespace Darkseed {
+
+KoFont::KoFont() {
+	Common::File fontData;
+	if (!fontData.open("k16.bin")) {
+		error("Error: failed to open k16.bin");
+	}
+
+	loadFontDataSet(_fontDataSet1, 191, 64, fontData);
+	loadFontDataSet(_fontDataSet2, 85, 64, fontData);
+	loadFontDataSet(_fontDataSet3, 109, 64, fontData);
+
+	Common::File fontOthersData;
+	if (!fontOthersData.open("others.bin")) {
+		error("Error: failed to open others.bin");
+	}
+
+	loadFontDataSet(_fontDataSetOther, 20, 32, fontOthersData);
+
+	fontOthersData.close();
+	fontData.close();
+
+	_gameFont = new GameFont();
+}
+
+KoFont::~KoFont() {
+	delete _gameFont;
+}
+
+void KoFont::loadFontDataSet(Common::Array<Common::Array<uint8> > &dataSet, int size, int packedGlyphSize, Common::File &file) {
+	dataSet.resize(size);
+
+	for (int i = 0; i < size; i++) {
+		dataSet[i].resize(packedGlyphSize * 4, 0);
+		loadFontGlyph(dataSet[i], packedGlyphSize, file);
+	}
+}
+
+static constexpr uint8 kFontPal[4] = {0, 2, 4, 11};
+
+void KoFont::loadFontGlyph(Common::Array<uint8> &pixels, int packedGlyphSize, Common::File &file) {
+	// Unpack 2bpp font data into 8bpp
+	for (int i = 0; i < packedGlyphSize; i++) {
+		uint8 byte = file.readByte();
+		for (int j = 0; j < 4; j++) {
+			pixels[i * 4 + j] = kFontPal[(byte >> (3 - j) * 2) & 3];
+		}
+	}
+}
+
+
+int KoFont::getFontHeight() const {
+	return 16;
+}
+
+int KoFont::getMaxCharWidth() const {
+	return 16;
+}
+
+int KoFont::getCharWidth(uint32 chr) const {
+	if (chr < 128) {
+		if (getOtherCharIdx(chr) != -1) {
+			return 10;
+		}
+		return _gameFont->getCharWidth(chr);
+	}
+	return getMaxCharWidth();
+}
+
+void KoFont::createGlyph(uint8 *pixels, uint32 chr) const {
+	uint16 param1, param2, param3;
+	extractKoIndexComponents(chr, &param1, &param2, &param3);
+	if (param1 < 191) {
+		addToGlyph(pixels, param1);
+	}
+	if (param2 < 85) {
+		addToGlyph(pixels, param2 + 191);
+	}
+	if (param3 < 109) {
+		addToGlyph(pixels, param3 + 276);
+	}
+}
+
+void KoFont::addToGlyph(uint8 *destPixels, int16 index) const {
+	if (index < 192) {
+		addPixels(destPixels, _fontDataSet1[index]);
+	} else if (index < 277) {
+		addPixels(destPixels, _fontDataSet2[index - 191]);
+	} else {
+		addPixels(destPixels, _fontDataSet3[index - 276]);
+	}
+}
+
+void KoFont::addPixels(uint8 *destPixels, const Common::Array<uint8> &pixels) const {
+	for (uint i = 0; i < pixels.size(); i++) {
+		if (pixels[i] != 0) {
+			destPixels[i] = pixels[i];
+		}
+	}
+}
+
+int16 SHORT_ARRAY_1000_01ca[32] = {
+	-1, 0, 32, 352,
+	672, 992, 1312, 1632,
+	1952, 2272, 2592, 2912,
+	3232, 3552, 3872, 4192,
+	4512, 4832, 5152, 5472,
+	5792, -1, -1, -1,
+	-1, -1, -1, -1,
+	-1, -1, -1, -1};
+
+int16 SHORT_ARRAY_1000_020a[32] = {
+	-1, -1, 0, 128,
+	256, 384, 512, 640,
+	-1, -1, 768, 896,
+	1024, 1152, 1280, 1408,
+	-1, -1, 1536, 1664,
+	1792, 1920, 2048, 2176,
+	-1, -1, 2304, 2432,
+	2560, 2688, -1, -1};
+
+int16 SHORT_ARRAY_1000_024a[32] = {
+	-1, 0, 128, 256,
+	384, 512, 640, 768,
+	896, 1024, 1152, 1280,
+	1408, 1536, 1664, 1792,
+	1920, 2048, -1, 2176,
+	2304, 2432, 2560, 2688,
+	2816, 2944, 3072, 3200,
+	3328, 3456, -1, -1};
+
+int16 SHORT_ARRAY_1000_028a[32] = {
+	-1, 0, 0, 64,
+	64, 64, 64, 64,
+	64, 64, 64, 64,
+	64, 64, 64, 64,
+	64, 0, 64, 64,
+	64, -1, -1, -1,
+	-1, -1, -1, -1,
+	-1, -1, -1, -1};
+
+int16 SHORT_ARRAY_1000_02ca[32] = {
+	0, 0, 0, 0,
+	0, 0, 0, 0,
+	0, 0, 0, 0,
+	0, 64, 192, 192,
+	0, 0, 192, 64,
+	128, 256, 256, 256,
+	0, 0, 128, 64,
+	192, 0, 0, 0};
+
+int16 SHORT_ARRAY_1000_030a[32] = {
+	0, 0, 0, 0,
+	64, 0, 64, 32,
+	0, 0, 64, 32,
+	64, 96, 0, 64,
+	0, 0, 32, 96,
+	96, 32, 64, 32,
+	0, 0, 96, 96,
+	32, 32, 0, 0};
+
+int16 SHORT_ARRAY_1000_034a[32] = {
+	-1, 0, 32, 32,
+	32, 32, 32, 32,
+	32, 32, 32, 32,
+	32, 32, 32, 32,
+	32, 32, -1, 32,
+	32, 32, 32, 32,
+	32, 32, 32, 32,
+	32, 32, -1, -1};
+
+void KoFont::extractKoIndexComponents(uint32 charIdx, uint16 *param_2, uint16 *param_3, uint16 *param_4) {
+	int uVar1;
+	int iVar2;
+	int uVar3;
+	int uVar4;
+	int uVar5;
+
+	iVar2 = (charIdx & 31) * 2;
+	uVar5 = (charIdx << 1) >> 5 & 62;
+	uVar4 = (charIdx << 1) >> 10 & 62;
+	uVar1 = SHORT_ARRAY_1000_020a[uVar5 / 2];
+	if (uVar1 > 0) {
+		uVar1 += SHORT_ARRAY_1000_028a[uVar4 / 2] + SHORT_ARRAY_1000_034a[iVar2 / 2] - 3;
+	}
+	uVar4 = SHORT_ARRAY_1000_01ca[uVar4 / 2];
+	if (uVar4 > 0) {
+		uVar4 += SHORT_ARRAY_1000_02ca[uVar5 / 2] + SHORT_ARRAY_1000_034a[iVar2 / 2];
+	}
+	uVar3 = SHORT_ARRAY_1000_024a[iVar2 / 2];
+	if (uVar3 > 0) {
+		uVar3 += SHORT_ARRAY_1000_030a[uVar5 / 2] - 3;
+	}
+	*param_2 = uVar4 >> 5;
+	*param_3 = (uVar1 >> 5) - 2;
+	*param_4 = (uVar3 >> 5) - 2;
+}
+
+bool KoFont::isConsonant(uint32 charIdx) {
+	uint16 param1, param2, param3;
+	extractKoIndexComponents(charIdx, &param1, &param2, &param3);
+	return param3 < 109;
+}
+
+Common::U32String KoFont::getObjectString(const Common::U32String &object) {
+	if (object.size() == 0) {
+		return Common::U32String("");
+	}
+	if (isConsonant(object[object.size() - 1])) {
+		return object + convertToU32String("\xb7\x69", Common::KO_KOR); // -eul
+	}
+	return object + convertToU32String("\x9f\x69", Common::KO_KOR); // -reul
+}
+
+Common::U32String KoFont::getTopicString(const Common::U32String &object) {
+	if (object.size() == 0) {
+		return Common::U32String("");
+	}
+	if (isConsonant(object[object.size() - 1])) {
+		return object + convertToU32String("\xb7\x65", Common::KO_KOR); // -eun
+	}
+	return object + convertToU32String("\x93\x65", Common::KO_KOR); // -neun
+}
+
+Common::U32String KoFont::getLinkingString(const Common::U32String &object) {
+	if (object.size() == 0) {
+		return Common::U32String("");
+	}
+	if (isConsonant(object[object.size() - 1])) {
+		return object + convertToU32String("\x89\xc1", Common::KO_KOR); // -gwa
+	}
+	return object + convertToU32String("\xb5\xc1", Common::KO_KOR); // -wa
+}
+
+Common::U32String KoFont::getLocationString(const Common::U32String &object) {
+	if (object.size() == 0) {
+		return Common::U32String("");
+	}
+	if (isConsonant(object[object.size() - 1])) {
+		return object + convertToU32String("\xb7\x61", Common::KO_KOR); // -eu
+	}
+	return object;
+}
+
+int KoFont::getOtherCharIdx(uint32 chr) const {
+	switch (chr) {
+	case '!':
+		return 2;
+	case '"':
+		return 6;
+	case '(':
+		return 3;
+	case ')':
+		return 4;
+	case ',':
+		return 0;
+	case '.':
+		return 1;
+	case '?':
+		return 5;
+	default:
+		break;
+	}
+	return -1;
+}
+
+void KoFont::drawOtherGlyph(Graphics::Surface *dst, uint8 chr, int x, int y) const {
+	g_engine->_screen->copyRectToSurfaceWithKey(_fontDataSetOther[chr].data(), 8, x, y, 8, 16,0xf);
+}
+
+void KoFont::drawChar(Graphics::Surface *dst, uint32 chr, int x, int y, uint32 color) const {
+	if (chr < 128) {
+		int otherCharIdx = getOtherCharIdx(chr);
+		if (otherCharIdx != -1) {
+			drawOtherGlyph(dst, (uint8)otherCharIdx, x, y);
+		} else {
+			_gameFont->drawChar(dst, chr, x, y, color);
+		}
+		return;
+	}
+	uint8 pixels[256];
+	memset(pixels, 0, 256);
+	createGlyph(pixels, chr);
+	g_engine->_screen->copyRectToSurfaceWithKey(pixels, 16, x, y - 2, 16, 16,0xf);
+}
+
+} // namespace Darkseed