tiberium/CNC_TS_and_RA2_Mission_Editor
1
0
Fork 0
mirror of https://github.com/electronicarts/CNC_TS_and_RA2_Mission_Editor.git synced 2025-03-21 11:21:21 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
CNC_TS_and_RA2_Mission_Editor/MissionEditor/TileSetBrowserView.cpp

1087 lines
25 KiB
C++
Raw Permalink Normal View History

TS_RA2_Mission_Editor_sourcecode_23.02.2023_1 TS_RA2_Mission_Editor_sourcecode_23.02.2023_1
2024-03-05 11:56:45 -08:00
/*
FinalSun/FinalAlert 2 Mission Editor
Copyright (C) 1999-2024 Electronic Arts, Inc.
Authored by Matthias Wagner
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 <https://www.gnu.org/licenses/>.
*/
// TileSetBrowserView.cpp: Implementierungsdatei
//
#include "stdafx.h"
#include "finalsun.h"
#include "TileSetBrowserView.h"
#include "FinalSunDlg.h"
#include "mapdata.h"
#include "variables.h"
#include "functions.h"
extern ACTIONDATA AD;
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CTileSetBrowserView
IMPLEMENT_DYNCREATE(CTileSetBrowserView, CScrollView)
CTileSetBrowserView::CTileSetBrowserView()
{
m_lpDDS = NULL;
m_bottom_needed = 1000;
m_CurrentMode = 0;
}
CTileSetBrowserView::~CTileSetBrowserView()
{
if (m_lpDDS)
{
int i;
for (i = 0;i < m_tilecount;i++)
{
if (m_lpDDS[i]) m_lpDDS[i]->Release();
}
delete[] m_lpDDS;
}
m_lpDDS = NULL;
}
BEGIN_MESSAGE_MAP(CTileSetBrowserView, CScrollView)
//{{AFX_MSG_MAP(CTileSetBrowserView)
ON_WM_LBUTTONDOWN()
ON_WM_VSCROLL()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// Zeichnung CTileSetBrowserView
void CTileSetBrowserView::OnInitialUpdate()
{
CScrollView::OnInitialUpdate();
}
// for fast overlay drawing use IsoView´s overlay table
extern PICDATA* ovrlpics[0xFF][max_ovrl_img];
void CTileSetBrowserView::OnDraw(CDC* pDC)
{
//ReleaseDC(pDC);
if (((CFinalSunDlg*)theApp.m_pMainWnd)->m_view.m_isoview->b_IsLoading || ((CFinalSunDlg*)theApp.m_pMainWnd)->m_view.m_isoview->lpds == NULL || ((CFinalSunDlg*)theApp.m_pMainWnd)->m_view.m_isoview->lpds->IsLost() != DD_OK)
return;
RECT r;
GetClientRect(&r);
if (tiledata == NULL || (*tiledata) == NULL)
return;
if (m_tilecount == 0)
return;
if (m_tile_width == 0)
return; // just to make sure I never divide through 0 here...
int max_r = r.right / m_tile_width;
int cur_y = 0;
int cur_x = 0;
if (m_CurrentMode == 1)
{
DWORD dwID = GetTileID(m_currentTileSet, 0);
int i;
for (i = 0;i < m_tilecount;i++)
{
char c[50];
itoa(i, c, 10);
int curwidth = (*tiledata)[dwID].rect.right - (*tiledata)[dwID].rect.left;
int curheight = GetAddedHeight(dwID) + (*tiledata)[dwID].rect.bottom - (*tiledata)[dwID].rect.top;
//pDC.TextOut(cur_x, cur_y, c);
#ifdef RA2_MODE
if ((m_currentTileSet == 80 && Map->GetTheater() == "TEMPERATE") || (m_currentTileSet == 73 && Map->GetTheater() == "SNOW") || (m_currentTileSet == 101 && Map->GetTheater() == "URBAN"))
{
if (i == 10 || i == 15)
{
dwID++; // don´t forget this here, too
continue;
}
}
#endif
if (!m_lpDDS[i]) continue;
RECT r;
GetClientRect(&r);
if (cur_y + curheight + (m_tile_height - curheight) / 2 >= this->GetScrollPos(SB_VERT) && cur_y <= GetScrollPos(SB_VERT) + r.bottom)
{
HDC hDC = NULL;
m_lpDDS[i]->GetDC(&hDC);
HDC hTmpDC = CreateCompatibleDC(hDC);
HBITMAP hBitmap = CreateCompatibleBitmap(hDC, curwidth, curheight);
SelectObject(hTmpDC, hBitmap);
BitBlt(hTmpDC, 0, 0, curwidth, curheight, hDC, 0, 0, SRCCOPY);
m_lpDDS[i]->ReleaseDC(hDC);
BitBlt(pDC->GetSafeHdc(), cur_x + (m_tile_width - curwidth) / 2, cur_y + (m_tile_height - curheight) / 2, curwidth, curheight, hTmpDC, 0, 0, SRCCOPY);
DeleteDC(hTmpDC);
DeleteObject(hBitmap);
if (AD.mode == ACTIONMODE_SETTILE && AD.type == dwID)
{
CPen p;
CBrush b;
p.CreatePen(PS_SOLID, 1, RGB(255, 0, 0));
b.CreateStockObject(NULL_BRUSH);
CPen* old = pDC->SelectObject(&p);
pDC->SetBkMode(TRANSPARENT);
pDC->SelectObject(&b);
pDC->Rectangle(cur_x + 2, cur_y + 2, cur_x + m_tile_width - 2, cur_y + m_tile_height - 2);
pDC->SelectObject(old);
}
}
cur_x += m_tile_width;
if (max_r == 0) max_r = 1;
if (i % max_r == max_r - 1)
{
cur_y += m_tile_height;
cur_x = 0;
}
dwID++;
}
}
#ifndef NOSURFACES
else if (m_CurrentMode == 2)
{
int i;
for (i = 0;i < max_ovrl_img;i++)
{
PICDATA* p = ovrlpics[m_currentOverlay][i];
if (p != NULL && p->pic != NULL)
{
DDSURFACEDESC2 desc;
memset(&desc, 0, sizeof(DDSURFACEDESC2));
desc.dwSize = sizeof(DDSURFACEDESC2);
desc.dwFlags = DDSD_WIDTH | DDSD_HEIGHT;
p->pic->GetSurfaceDesc(&desc);
int curwidth = desc.dwWidth;
int curheight = desc.dwHeight;
HDC hDC = NULL;
p->pic->GetDC(&hDC);
HDC hTmpDC = CreateCompatibleDC(hDC);
HBITMAP hBitmap = CreateCompatibleBitmap(hDC, curwidth, curheight);
SelectObject(hTmpDC, hBitmap);
BitBlt(hTmpDC, 0, 0, curwidth, curheight, hDC, 0, 0, SRCCOPY);
p->pic->ReleaseDC(hDC);
BitBlt(pDC->GetSafeHdc(), cur_x + (m_tile_width - curwidth) / 2, cur_y + (m_tile_height - curheight) / 2, curwidth, curheight, hTmpDC, 0, 0, SRCCOPY);
DeleteDC(hTmpDC);
DeleteObject(hBitmap);
if (AD.mode == ACTIONMODE_PLACE && AD.data2 == m_currentOverlay && AD.data3 == i && AD.data == 33 && AD.type == 6)
{
CPen p;
CBrush b;
p.CreatePen(PS_SOLID, 1, RGB(255, 0, 0));
b.CreateStockObject(NULL_BRUSH);
CPen* old = pDC->SelectObject(&p);
pDC->SetBkMode(TRANSPARENT);
pDC->SelectObject(&b);
pDC->Rectangle(cur_x + 2, cur_y + 2, cur_x + m_tile_width - 2, cur_y + m_tile_height - 2);
pDC->SelectObject(old);
}
cur_x += m_tile_width;
if (max_r == 0) max_r = 1;
if (i % max_r == max_r - 1)
{
cur_y += m_tile_height;
cur_x = 0;
}
}
}
}
#else
else if (m_CurrentMode == 2)
{
int i;
for (i = 0;i < max_ovrl_img;i++)
{
PICDATA* p = ovrlpics[m_currentOverlay][i];
if (p != NULL && p->pic != NULL)
{
int curwidth = p->wMaxWidth;
int curheight = p->wMaxHeight;
BITMAPINFO biinfo;
memset(&biinfo, 0, sizeof(BITMAPINFO));
biinfo.bmiHeader.biBitCount = 24;
biinfo.bmiHeader.biWidth = curwidth;
biinfo.bmiHeader.biHeight = curheight;
biinfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
biinfo.bmiHeader.biClrUsed = 0;
biinfo.bmiHeader.biPlanes = 1;
biinfo.bmiHeader.biCompression = BI_RGB;
biinfo.bmiHeader.biClrImportant = 0;
int pitch = curwidth * 3;
if (pitch == 0)
continue;
if (pitch % sizeof(DWORD))
{
pitch += sizeof(DWORD) - (curwidth * 3) % sizeof(DWORD);
}
BYTE* colors = new(BYTE[pitch * curheight]);
memset(colors, 255, pitch * (curheight));
RGBTRIPLE* pal = palIso;
if (p->pal == iPalTheater)
pal = palTheater;
if (p->pal == iPalUnit)
pal = palUnit;
int k, l;
for (k = 0;k < curheight;k++)
{
for (l = 0;l < curwidth;l++)
{
if (((BYTE*)p->pic)[l + k * curwidth])
{
memcpy(&colors[l * 3 + (curheight - k - 1) * pitch], &pal[((BYTE*)p->pic)[l + k * curwidth]], 3);
}
}
}
StretchDIBits(pDC->GetSafeHdc(), cur_x + (m_tile_width - curwidth) / 2, cur_y + (m_tile_height - curheight) / 2, curwidth, curheight,
0, 0, curwidth, curheight, colors, &biinfo, DIB_RGB_COLORS, SRCCOPY);
delete[] colors;
if (AD.mode == ACTIONMODE_PLACE && AD.data2 == m_currentOverlay && AD.data3 == i && AD.data == 33 && AD.type == 6)
{
CPen p;
CBrush b;
p.CreatePen(PS_SOLID, 1, RGB(255, 0, 0));
b.CreateStockObject(NULL_BRUSH);
CPen* old = pDC->SelectObject(&p);
pDC->SetBkMode(TRANSPARENT);
pDC->SelectObject(&b);
pDC->Rectangle(cur_x + 2, cur_y + 2, cur_x + m_tile_width - 2, cur_y + m_tile_height - 2);
pDC->SelectObject(old);
}
cur_x += m_tile_width;
if (max_r == 0)
max_r = 1;
if (i % max_r == max_r - 1)
{
cur_y += m_tile_height;
cur_x = 0;
}
}
}
}
#endif
}
/////////////////////////////////////////////////////////////////////////////
// Diagnose CTileSetBrowserView
#ifdef _DEBUG
void CTileSetBrowserView::AssertValid() const
{
CScrollView::AssertValid();
}
void CTileSetBrowserView::Dump(CDumpContext& dc) const
{
CScrollView::Dump(dc);
}
#endif //_DEBUG
/////////////////////////////////////////////////////////////////////////////
// Behandlungsroutinen für Nachrichten CTileSetBrowserView
void CTileSetBrowserView::PostNcDestroy()
{
// TODO: Speziellen Code hier einfügen und/oder Basisklasse aufrufen
// CScrollView::PostNcDestroy();
}
DWORD CTileSetBrowserView::GetTileID(DWORD dwTileSet, DWORD dwType)
{
int i, e;
DWORD tilecount = 0;
for (i = 0;i < 10000;i++)
{
CString tset;
char c[50];
itoa(i, c, 10);
int e;
for (e = 0;e < 4 - strlen(c);e++)
tset += "0";
tset += c;
CString sec = "TileSet";
sec += tset;
if (tiles->sections.find(sec) == tiles->sections.end())
return 0xFFFFFFFF;
for (e = 0;e < atoi(tiles->sections[sec].values["TilesInSet"]);e++)
{
if (i == dwTileSet && e == dwType)
return tilecount;
tilecount++;
}
}
return tilecount;
}
void CTileSetBrowserView::SetTileSet(DWORD dwTileSet, BOOL bOnlyRedraw)
{
m_currentTileSet = dwTileSet;
m_CurrentMode = 1;
char currentTileSet[50];
itoa(m_currentTileSet, currentTileSet, 10);
CString tset;
int e;
for (e = 0;e < 4 - strlen(currentTileSet);e++)
tset += "0";
tset += currentTileSet;
m_tile_width = 0;
m_tile_height = 0;
int i;
int max = atoi(tiles->sections[(CString)"TileSet" + tset].values["TilesInSet"]);
DWORD dwStartID = GetTileID(dwTileSet, 0);
if ((*tiledata)[dwStartID].wTileCount && (*tiledata)[dwStartID].tiles[0].pic)
{
if (!bOnlyRedraw)
{
AD.mode = ACTIONMODE_SETTILE;
AD.type = dwStartID;
AD.data = 0;
AD.data2 = 0;
AD.z_data = 0;
((CFinalSunDlg*)theApp.m_pMainWnd)->m_settingsbar.m_BrushSize = 0;
((CFinalSunDlg*)theApp.m_pMainWnd)->m_settingsbar.UpdateData(FALSE);
((CFinalSunDlg*)theApp.m_pMainWnd)->m_view.m_isoview->m_BrushSize_x = 1;
((CFinalSunDlg*)theApp.m_pMainWnd)->m_view.m_isoview->m_BrushSize_y = 1;
int i;
for (i = 0;i < g_data.sections["StdBrushSize"].values.size();i++)
{
CString n = *g_data.sections["StdBrushSize"].GetValueName(i);
if ((*tiles).sections["General"].FindName(n) >= 0)
{
int tset = atoi((*tiles).sections["General"].values[n]);
if (tset == m_currentTileSet)
{
int bs = atoi(*g_data.sections["StdBrushSize"].GetValue(i));
((CFinalSunDlg*)theApp.m_pMainWnd)->m_settingsbar.m_BrushSize = bs - 1;
((CFinalSunDlg*)theApp.m_pMainWnd)->m_settingsbar.UpdateData(FALSE);
((CFinalSunDlg*)theApp.m_pMainWnd)->m_view.m_isoview->m_BrushSize_x = bs;
((CFinalSunDlg*)theApp.m_pMainWnd)->m_view.m_isoview->m_BrushSize_y = bs;
}
}
}
}
}
DWORD dwID;
for (i = 0;i < max;i++)
{
CString str;
char c[50];
itoa(i, c, 10);
for (e = 0;e < 2 - strlen(c);e++)
str += "0";
str += c;
dwID = dwStartID + i; // just faster than always calling GetTileID()
if (dwID < *tiledata_count)
{
if ((*tiledata)[dwID].rect.right - (*tiledata)[dwID].rect.left > m_tile_width) m_tile_width = (*tiledata)[dwID].rect.right - (*tiledata)[dwID].rect.left;
if (GetAddedHeight(dwID) + (*tiledata)[dwID].rect.bottom - (*tiledata)[dwID].rect.top > m_tile_height) m_tile_height = GetAddedHeight(dwID) + (*tiledata)[dwID].rect.bottom - (*tiledata)[dwID].rect.top;
}
}
m_tile_width += 6;
m_tile_height += 6;
if (m_lpDDS)
{
int i;
for (i = 0;i < m_tilecount;i++)
{
if (m_lpDDS[i]) m_lpDDS[i]->Release();
}
delete[] m_lpDDS;
}
m_tilecount = max;
m_lpDDS = new(LPDIRECTDRAWSURFACE4[m_tilecount]);
for (i = 0;i < m_tilecount;i++)
{
m_lpDDS[i] = RenderTile(dwStartID + i);
}
RECT r;
GetClientRect(&r);
int max_r = r.right / m_tile_width;
if (max_r <= 0) max_r = 1;
m_bottom_needed = m_tile_height * (1 + m_tilecount / max_r);
GetParentFrame()->RecalcLayout(TRUE);
RedrawWindow();
((CFinalSunDlg*)theApp.m_pMainWnd)->m_view.m_isoview->SetForegroundWindow();
((CFinalSunDlg*)theApp.m_pMainWnd)->m_view.m_isoview->SetFocus();
//DrawIt();
}
#ifdef NOSURFACES
struct BlitRect
{
short left;
short top;
short right;
short bottom;
};
__forceinline void BlitTerrainTSB(void* dst, int x, int y, int dleft, int dtop, int dpitch, int dright, int dbottom, SUBTILE& st)//BYTE* src, int swidth, int sheight)
{
BYTE* src = st.pic;
unsigned short& swidth = st.wWidth;
unsigned short& sheight = st.wHeight;
if (src == NULL || dst == NULL)
return;
if (x + swidth < dleft || y + sheight < dtop)
return;
if (x >= dright || y >= dbottom)
return;
BlitRect blrect;
BlitRect srcRect;
srcRect.left = 0;
srcRect.top = 0;
srcRect.right = swidth;
srcRect.bottom = sheight;
blrect.left = x;
if (blrect.left < 0)
{
srcRect.left = 1 - blrect.left;
blrect.left = 1;
}
blrect.top = y;
if (blrect.top < 0)
{
srcRect.top = 1 - blrect.top;
blrect.top = 1;
}
blrect.right = (x + swidth);
if (x + swidth > dright)
{
srcRect.right = dright - x;//swidth-((x+swidth)-dright);
blrect.right = dright;
}
blrect.bottom = (y + sheight);
if (y + sheight > dbottom)
{
srcRect.bottom = dbottom - y;//sheight-((y+sheight)-dbottom);
blrect.bottom = dbottom;
}
short i, e;
#ifdef NOSURFACES_EXTRACT
int pos = 0;
if (!st.bNotExtracted)
{
for (e = srcRect.top;e < srcRect.bottom;e++)
{
short& left = st.vborder[e].left;
short& right = st.vborder[e].right;
if (right >= left)
{
void* dest = ((BYTE*)dst + (blrect.left + left) * bpp + (blrect.top + e) * dpitch);
memcpy(dest, &st.pic[pos], bpp * (right - left + 1));
pos += (right - left + 1) * bpp;
}
}
}
else
#endif
for (e = srcRect.top;e < srcRect.bottom;e++)
{
short& left = st.vborder[e].left;
short& right = st.vborder[e].right;
for (i = left;i <= right;i++)
{
if (i < srcRect.left || i >= srcRect.right)
{
//dest+=bpp;
}
else
{
BYTE& val = src[i + e * swidth];
if (val)
{
void* dest = ((BYTE*)dst + (blrect.left + i) * bpp + (blrect.top + e) * dpitch);
memcpy(dest, &iPalIso[val], bpp);
}
}
}
}
}
#endif
LPDIRECTDRAWSURFACE4 CTileSetBrowserView::RenderTile(DWORD dwID)
{
if (theApp.m_Options.bMarbleMadness)
{
if ((*tiledata)[dwID].wMarbleGround != 0xFFFF)
{
dwID = (*tiledata)[dwID].wMarbleGround;
}
}
LPDIRECTDRAWSURFACE4 lpdds = NULL;
LPDIRECTDRAW4 lpdd = ((CFinalSunDlg*)theApp.m_pMainWnd)->m_view.m_isoview->dd;
DDSURFACEDESC2 ddsd;
memset(&ddsd, 0, sizeof(DDSURFACEDESC2));
ddsd.dwSize = sizeof(DDSURFACEDESC2);
ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
int added_height = GetAddedHeight(dwID);
ddsd.dwHeight = (*tiledata)[dwID].rect.bottom - (*tiledata)[dwID].rect.top + added_height;
ddsd.dwWidth = (*tiledata)[dwID].rect.right - (*tiledata)[dwID].rect.left;
if (lpdd->CreateSurface(&ddsd, &lpdds, NULL) != DD_OK)
{
return NULL;
}
DDBLTFX ddfx;
memset(&ddfx, 0, sizeof(DDBLTFX));
ddfx.dwSize = sizeof(DDBLTFX);
lpdds->Blt(NULL, NULL, NULL, DDBLT_COLORFILL, &ddfx);
int y_added = ddsd.dwHeight - ((*tiledata)[dwID].cx * f_y / 2 + (*tiledata)[dwID].cy * f_y / 2);
int i, e, p = 0;;
for (i = 0;i < (*tiledata)[dwID].cx;i++)
{
for (e = 0;e < (*tiledata)[dwID].cy;e++)
{
int drawx = e * f_x / 2 - i * f_x / 2 - (*tiledata)[dwID].rect.left;
int drawy = e * f_y / 2 + i * f_y / 2 - (*tiledata)[dwID].rect.top;
drawx += (*tiledata)[dwID].tiles[p].sX;
drawy += added_height + (*tiledata)[dwID].tiles[p].sY - (*tiledata)[dwID].tiles[p].bZHeight * f_y / 2;
//drawy+=y_added;
if ((*tiledata)[dwID].tiles[p].pic)
{
RECT dest;
dest.left = drawx;
dest.top = drawy;
dest.right = drawx + (*tiledata)[dwID].tiles[p].wWidth;
dest.bottom = drawy + (*tiledata)[dwID].tiles[p].wHeight;
DDBLTFX fx;
memset(&fx, 0, sizeof(DDBLTFX));
fx.dwSize = sizeof(DDBLTFX);
#ifndef NOSURFACES
if (lpdds->Blt(&dest, (*tiledata)[dwID].tiles[p].pic, NULL, DDBLT_KEYSRC, &fx) != DD_OK)
TRACE("Blit failed\n");
#else
DDSURFACEDESC2 ddsd;
ZeroMemory(&ddsd, sizeof(ddsd));
ddsd.dwSize = sizeof(DDSURFACEDESC2);
ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT;
lpdds->GetSurfaceDesc(&ddsd);
lpdds->Lock(NULL, &ddsd, DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT | DDLOCK_NOSYSLOCK, NULL);
BlitTerrainTSB(ddsd.lpSurface, drawx, drawy, 0, 0, ddsd.lPitch, ddsd.dwWidth, ddsd.dwHeight, (*tiledata)[dwID].tiles[p]);
lpdds->Unlock(NULL);
#endif
}
p++;
}
}
FSunPackLib::SetColorKey(lpdds, -1);
return lpdds;
}
void CTileSetBrowserView::DrawIt()
{
CPaintDC myDC(this);
}
void CTileSetBrowserView::OnLButtonDown(UINT nFlags, CPoint point)
{
RECT r;
GetClientRect(&r);
if (m_tilecount == 0)
return;
SCROLLINFO scrinfo;
scrinfo.cbSize = sizeof(SCROLLINFO);
scrinfo.fMask = SIF_ALL;
GetScrollInfo(SB_HORZ, &scrinfo);
point.x += scrinfo.nPos;
GetScrollInfo(SB_VERT, &scrinfo);
point.y += scrinfo.nPos;
int max_r = r.right / m_tile_width;
if (max_r == 0) max_r = 1;
int cur_y = 0;
int cur_x = 0;
int tile_width = m_tile_width;
int tile_height = m_tile_height;
if (m_CurrentMode == 1)
{
DWORD dwID = GetTileID(m_currentTileSet, 0);
int i;
for (i = 0;i < m_tilecount;i++)
{
int curwidth = (*tiledata)[dwID].rect.right - (*tiledata)[dwID].rect.left;
int curheight = (*tiledata)[dwID].rect.bottom - (*tiledata)[dwID].rect.top;
curwidth = m_tile_width;
curheight = m_tile_height;
#ifdef RA2_MODE
if ((m_currentTileSet == 80 && Map->GetTheater() == "TEMPERATE") || (m_currentTileSet == 73 && Map->GetTheater() == "SNOW") || (m_currentTileSet == 101 && Map->GetTheater() == "URBAN"))
{
if (i == 10 || i == 15)
{
dwID++; // don´t forget this
continue;
}
}
#endif
int posaddedx = (m_tile_width - curwidth) / 2;
int posaddedy = (m_tile_height - curheight) / 2;
if (point.x > cur_x + posaddedx && point.y > cur_y + posaddedy && point.x < cur_x + tile_width - posaddedx && point.y < cur_y + tile_height - posaddedy)
{
char c[50];
itoa(GetAddedHeight(dwID), c, 10);
OutputDebugString(c);
int oldmode = AD.mode;
int oldid = AD.type;
AD.mode = ACTIONMODE_SETTILE;
AD.type = dwID;
AD.data = 0;
AD.data2 = 0;
AD.data3 = 0;
AD.z_data = 0;
if (oldid > *tiledata_count) oldid = 0;
if (oldmode != ACTIONMODE_SETTILE || (*tiledata)[oldid].wTileSet != m_currentTileSet)
{
((CFinalSunDlg*)theApp.m_pMainWnd)->m_settingsbar.m_BrushSize = 0;
((CFinalSunDlg*)theApp.m_pMainWnd)->m_settingsbar.UpdateData(FALSE);
((CFinalSunDlg*)theApp.m_pMainWnd)->m_view.m_isoview->m_BrushSize_x = 1;
((CFinalSunDlg*)theApp.m_pMainWnd)->m_view.m_isoview->m_BrushSize_y = 1;
int i;
for (i = 0;i < g_data.sections["StdBrushSize"].values.size();i++)
{
CString n = *g_data.sections["StdBrushSize"].GetValueName(i);
if ((*tiles).sections["General"].FindName(n) >= 0)
{
int tset = atoi((*tiles).sections["General"].values[n]);
if (tset == m_currentTileSet)
{
int bs = atoi(*g_data.sections["StdBrushSize"].GetValue(i));
((CFinalSunDlg*)theApp.m_pMainWnd)->m_settingsbar.m_BrushSize = bs - 1;
((CFinalSunDlg*)theApp.m_pMainWnd)->m_settingsbar.UpdateData(FALSE);
((CFinalSunDlg*)theApp.m_pMainWnd)->m_view.m_isoview->m_BrushSize_x = bs;
((CFinalSunDlg*)theApp.m_pMainWnd)->m_view.m_isoview->m_BrushSize_y = bs;
}
}
}
}
RedrawWindow();
return;
}
cur_x += tile_width;
if (i % max_r == max_r - 1)
{
cur_y += tile_height;
cur_x = 0;
}
dwID++;
}
}
else if (m_CurrentMode == 2)
{
int i;
for (i = 0;i < max_ovrl_img;i++)
{
PICDATA* p = ovrlpics[m_currentOverlay][i];
if (p != NULL && p->pic != NULL)
{
int curwidth = m_tile_width;
int curheight = m_tile_height;
int posaddedx = (m_tile_width - curwidth) / 2;
int posaddedy = (m_tile_height - curheight) / 2;
if (point.x > cur_x + posaddedx && point.y > cur_y + posaddedy && point.x < cur_x + tile_width - posaddedx && point.y < cur_y + tile_height - posaddedy)
{
AD.mode = ACTIONMODE_PLACE;
AD.type = 6;
AD.data = 33;
AD.data2 = m_currentOverlay;
AD.data3 = i;
RedrawWindow();
return;
}
cur_x += tile_width;
if (i % max_r == max_r - 1)
{
cur_y += tile_height;
cur_x = 0;
}
}
}
}
((CFinalSunDlg*)theApp.m_pMainWnd)->m_view.m_isoview->SetForegroundWindow();
((CFinalSunDlg*)theApp.m_pMainWnd)->m_view.m_isoview->SetFocus();
CScrollView::OnLButtonDown(nFlags, point);
}
// calculates additional height added to the top of a tile if needed
int CTileSetBrowserView::GetAddedHeight(DWORD dwID)
{
//int i;
int cur_added = 0;
//for(i=0;i<(*tiledata)[dwID].wTileCount;i++)
{
int i, e, p = 0;;
for (i = 0;i < (*tiledata)[dwID].cx;i++)
{
for (e = 0;e < (*tiledata)[dwID].cy;e++)
{
int drawy = e * f_y / 2 + i * f_y / 2 - (*tiledata)[dwID].rect.top;
drawy += (*tiledata)[dwID].tiles[p].sY - (*tiledata)[dwID].tiles[p].bZHeight * f_y / 2;
if (drawy < cur_added) cur_added = drawy;
p++;
}
}
}
return -cur_added;
}
void CTileSetBrowserView::SetOverlay(DWORD dwID)
{
int k;
int need_pos = -1;
int need_width = 0;
int need_height = 0;
// m_tilecount=0;
int iovrlcount = 0;
BOOL bFound = FALSE;
for (k = 0;k < max_ovrl_img;k++)
{
PICDATA* p = ovrlpics[dwID][k];
if (p != NULL && p->pic != NULL)
{
bFound = TRUE;
}
}
if (!bFound)
{
theApp.m_loading->LoadOverlayGraphic(*rules.sections["OverlayTypes"].GetValue(dwID), dwID);
((CFinalSunDlg*)(theApp.m_pMainWnd))->m_view.m_isoview->UpdateOverlayPictures();
//p=ovrlpics[dwID][k];
}
for (k = 0;k < max_ovrl_img;k++)
{
PICDATA* p = ovrlpics[dwID][k];
if (p == NULL || p->pic == NULL)
{
//if(!p->bTried)
{
}
}
if (p != NULL && p->pic != NULL)
{
iovrlcount++;
}
}
for (k = 0;k < max_ovrl_img;k++)
{
PICDATA* p = ovrlpics[dwID][k];
if (p != NULL && p->pic != NULL)
{
need_pos = k;
need_width = p->wMaxWidth;
need_height = p->wMaxHeight;
break;
}
}
if (need_pos < 0)
return;
((CFinalSunDlg*)theApp.m_pMainWnd)->m_settingsbar.m_BrushSize = 0;
((CFinalSunDlg*)theApp.m_pMainWnd)->m_settingsbar.UpdateData(FALSE);
((CFinalSunDlg*)theApp.m_pMainWnd)->m_view.m_isoview->m_BrushSize_x = 1;
((CFinalSunDlg*)theApp.m_pMainWnd)->m_view.m_isoview->m_BrushSize_y = 1;
m_CurrentMode = 2;
m_tile_width = 0;
m_tile_height = 0;
m_currentOverlay = dwID;
m_tile_width = need_width + 6;
m_tile_height = need_height + 6;
RECT r;
GetClientRect(&r);
int max_r = r.right / m_tile_width;
if (max_r <= 0) max_r = 1;
m_bottom_needed = m_tile_height * (1 + (iovrlcount) / max_r);
GetParentFrame()->RecalcLayout(TRUE);
RedrawWindow();
((CFinalSunDlg*)theApp.m_pMainWnd)->m_view.m_isoview->SetForegroundWindow();
((CFinalSunDlg*)theApp.m_pMainWnd)->m_view.m_isoview->SetFocus();
}
#ifdef IGNORETHIS
LPDIRECTDRAWSURFACE4 CTileSetBrowserView::RenderOverlay(DWORD dwType, DWORD dwData)
{
LPDIRECTDRAWSURFACE4 lpdds = NULL;
LPDIRECTDRAW4 lpdd = ((CFinalSunDlg*)theApp.m_pMainWnd)->m_view.m_isoview->dd;
DDSURFACEDESC2 ddsd;
memset(&ddsd, 0, sizeof(DDSURFACEDESC2));
ddsd.dwSize = sizeof(DDSURFACEDESC2);
ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
int added_height = GetAddedHeight(dwID);
ddsd.dwHeight =//(*tiledata)[dwID].rect.bottom-(*tiledata)[dwID].rect.top+added_height;
ddsd.dwWidth = (*tiledata)[dwID].rect.right - (*tiledata)[dwID].rect.left;
if (lpdd->CreateSurface(&ddsd, &lpdds, NULL) != DD_OK)
{
return NULL;
}
DDBLTFX ddfx;
memset(&ddfx, 0, sizeof(DDBLTFX));
ddfx.dwSize = sizeof(DDBLTFX);
lpdds->Blt(NULL, NULL, NULL, DDBLT_COLORFILL, &ddfx);
int y_added = ddsd.dwHeight - ((*tiledata)[dwID].cx * f_y / 2 + (*tiledata)[dwID].cy * f_y / 2);
int i, e, p = 0;;
for (i = 0;i < (*tiledata)[dwID].cx;i++)
{
for (e = 0;e < (*tiledata)[dwID].cy;e++)
{
int drawx = e * f_x / 2 - i * f_x / 2 - (*tiledata)[dwID].rect.left;
int drawy = e * f_y / 2 + i * f_y / 2 - (*tiledata)[dwID].rect.top;
drawx += (*tiledata)[dwID].tiles[p].sX;
drawy += added_height + (*tiledata)[dwID].tiles[p].sY - (*tiledata)[dwID].tiles[p].bZHeight * f_y / 2;
//drawy+=y_added;
if ((*tiledata)[dwID].tiles[p].pic)
{
RECT dest;
dest.left = drawx;
dest.top = drawy;
dest.right = drawx + (*tiledata)[dwID].tiles[p].wWidth;
dest.bottom = drawy + (*tiledata)[dwID].tiles[p].wHeight;
DDBLTFX fx;
memset(&fx, 0, sizeof(DDBLTFX));
fx.dwSize = sizeof(DDBLTFX);
DDSURFACEDESC2 ddsd;
ZeroMemory(&ddsd, sizeof(ddsd));
ddsd.dwSize = sizeof(DDSURFACEDESC2);
ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT;
lpdds->GetSurfaceDesc(&ddsd);
lpdds->Lock(NULL, &ddsd, DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT | DDLOCK_NOSYSLOCK, NULL);
BlitTerrainTSB(ddsd.lpSurface, drawx, drawy, 0, 0, ddsd.lPitch, ddsd.dwWidth, ddsd.dwHeight, (*tiledata)[dwID].tiles[p]);
lpdds->Unlock(NULL);
}
p++;
}
}
SetSurfaceColorKey(lpdds, -1);
}
#endif
void CTileSetBrowserView::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
{
//RedrawWindow(NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW);
CScrollView::OnVScroll(nSBCode, nPos, pScrollBar);
}
Reference in a new issue Copy permalink