drudge/animated-render.star.py

## animated-render.star.py
# Tidbyt Xbox Live App
# MIT License
# by Nicholas Penree, Dec 19 2021

load("render.star", "render")
load("http.star", "http")
load("encoding/base64.star", "base64")
load("cache.star", "cache")

MOCK = False

INTRO = base64.decode("""
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
""")

BG = base64.decode("""
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
""")


def get_config(config):
    if MOCK:
        return dict(
            gamer_tag="ac1dburn",
            gamer_score="10808",
        )
    return config

def main(config):
    config = get_config(config)
    gamer_score = config.get("gamer_score", "---")
    frames = []

    # intro animation
    for i in range(82):
        frames.append(
            render.Box(
                child = render.Stack(
                    children=[
                        render.Image(
                            src=INTRO,
                            width=64,
                        ),
                    ],
                )
            )
        )

    for i in range(80):
        off = i % 2 == 0
        color = "#000"
        if off:
            color = "#111"

        frames.append(
            render.Box(
                child = render.Stack(
                    children =[
                        render.Box(
                            child = render.Image(
                                src = BG,
                                width = 64,
                            ),
                        ),
                        render.Padding(
                            pad = (13, 11, 0, 1),
                            child = render.Text(
                                content = "G",
                                color = color,
                                font = "Dina_r400-6"
                            ),
                        ),
                        render.Box(
                            child = render.Padding(
                                pad = (9, 0, 0, 0),
                                child = render.Text(
                                    content = gamer_score,
                                    font = "Dina_r400-6"
                                )
                            ),
                        )
                    ],
                )
            )
        )

    return render.Root(
        child = render.Animation(children = frames)
    )

## config.js
/*!
 * Tidbyt Xbox Live App
 * MIT License
 * by Nicholas Penree, Dec 29 2021
 */
const { authenticateWithUserRefreshToken } = require('@xboxreplay/xboxlive-auth')
const XboxLiveAPI = require('@xboxreplay/xboxlive-api')

async function fetch(config = []) {
    let auth
    let playerSettings
    let { value: refreshToken } = (config || []).find(c => c.key === 'refresh_token') || {}
    let { value: clientId } = (config || []).find(c => c.key === 'client_id') || {}

    if (!clientId) {
        // Defaults to the live (live.com) client ID used by the official Xbox desktop / mobile
        // applications during the authentication (OAuth) process.
        // Each live application has its own ID but this one allows service::user.auth.xboxlive.com::MBI_SSL scope
        // usage which skip the authorization prompt and return user's token.
        //
        //    source: https://github.com/XboxReplay/xboxlive-auth/issues/16#issuecomment-815601103
        //
        clientId = process.env.XBOX_LIVE_CLIENT_ID || '0000000048093EE3'
    }

    if (!refreshToken) {
        refreshToken = process.env.XBOX_LIVE_REFRESH_TOKEN
    }

    try {
        auth = await authenticateWithUserRefreshToken(refreshToken, { clientId })
    } catch (err) {
        console.error(err.details)
    }

    const {
        user_hash: userHash,
        xuid,
        xsts_token: XSTSToken
    } = auth || {}

    if (xuid) {
        try {
            playerSettings = await XboxLiveAPI.getPlayerSettings(xuid, {
                userHash,
                XSTSToken,
            }, [
                'UniqueModernGamertag',
                // 'GameDisplayPicRaw',
                'Gamerscore',
            ])
        } catch (error) {
            console.error(error)
        }
    }

    playerSettings = playerSettings || []

    const { value: gamerTag } = playerSettings.find(x => x.id === 'UniqueModernGamertag') || {}
    const { value: gamerScore } = playerSettings.find(x => x.id === 'Gamerscore') || {}
    // const { value: avatarImageUrl } = playerSettings.find(x => x.id === 'GameDisplayPicRaw') || {}

    return [
        // ...config,
        { key: 'gamer_tag', value: gamerTag },
        { key: 'gamer_score', value: gamerScore },
        // { key: 'avatar_url', value: avatarImageUrl },
    ]
}

module.exports = fetch

## render.star.py
# Tidbyt Xbox Live App
# MIT License
# by Nicholas Penree, Dec 29 2021

load("render.star", "render")
load("http.star", "http")
load("encoding/base64.star", "base64")
load("cache.star", "cache")

MOCK=False

def get_config(config):
    if MOCK:
        return dict(
            gamer_tag = "conceiteddrudge",
            gamer_score = "10808",
        )
    return config

def GamerScoreLogo():
    return render.Circle(
        color = "#fff",
        diameter = 13,
        child = render.Text(
            content = "G",
            color = "#000",
            font = "Dina_r400-6"
        ),
    )

def GamerScore(gamer_score):
    return render.Row(
        expanded=True,
        main_align="center",
        cross_align="center",
        children = [
            GamerScoreLogo(),
            render.Box(width = 1),
            render.Text(content = gamer_score),
        ],
    )

def main(config):
    settings = get_config(config)
    gamer_tag = settings.get('gamer_tag', '')
    gamer_score = settings.get('gamer_score', '')
    avatar_url = settings.get('avatar_url', '')
    children = []

    if avatar_url != '':
        children += [
            render.Box(height = 2),
            render.Image(src=http.get(avatar_url).body(), height=14, width=14)
        ]

    children += [ GamerScore(gamer_score) ]

    if gamer_tag != '':
        if settings.get('scroll', False) or len(gamer_tag) > 8:
            gamer_tag_child = render.Marquee(
                width = 64,
                child = render.Text(color = '#3c3c3c', content = gamer_tag),
            )
        else:
            gamer_tag_child = render.Text(color = '#3c3c3c', content = gamer_tag)
        children += [ gamer_tag_child ]

    return render.Root(
        child = render.Box(
            render.Column(
                expanded=True,
                main_align="center",
                cross_align="center",
                children = children,
            ),
        ),
    )
	/*!
	* Tidbyt Xbox Live App
	* MIT License
	* by Nicholas Penree, Dec 29 2021
	*/
	const { authenticateWithUserRefreshToken } = require('@xboxreplay/xboxlive-auth')
	const XboxLiveAPI = require('@xboxreplay/xboxlive-api')

	async function fetch(config = []) {
	let auth
	let playerSettings
	let { value: refreshToken } = (config \|\| []).find(c => c.key === 'refresh_token') \|\| {}
	let { value: clientId } = (config \|\| []).find(c => c.key === 'client_id') \|\| {}

	if (!clientId) {
	// Defaults to the live (live.com) client ID used by the official Xbox desktop / mobile
	// applications during the authentication (OAuth) process.
	// Each live application has its own ID but this one allows service::user.auth.xboxlive.com::MBI_SSL scope
	// usage which skip the authorization prompt and return user's token.
	//
	// source: https://github.com/XboxReplay/xboxlive-auth/issues/16#issuecomment-815601103
	//
	clientId = process.env.XBOX_LIVE_CLIENT_ID \|\| '0000000048093EE3'
	}

	if (!refreshToken) {
	refreshToken = process.env.XBOX_LIVE_REFRESH_TOKEN
	}

	try {
	auth = await authenticateWithUserRefreshToken(refreshToken, { clientId })
	} catch (err) {
	console.error(err.details)
	}

	const {
	user_hash: userHash,
	xuid,
	xsts_token: XSTSToken
	} = auth \|\| {}

	if (xuid) {
	try {
	playerSettings = await XboxLiveAPI.getPlayerSettings(xuid, {
	userHash,
	XSTSToken,
	}, [
	'UniqueModernGamertag',
	// 'GameDisplayPicRaw',
	'Gamerscore',
	])
	} catch (error) {
	console.error(error)
	}
	}

	playerSettings = playerSettings \|\| []

	const { value: gamerTag } = playerSettings.find(x => x.id === 'UniqueModernGamertag') \|\| {}
	const { value: gamerScore } = playerSettings.find(x => x.id === 'Gamerscore') \|\| {}
	// const { value: avatarImageUrl } = playerSettings.find(x => x.id === 'GameDisplayPicRaw') \|\| {}

	return [
	// ...config,
	{ key: 'gamer_tag', value: gamerTag },
	{ key: 'gamer_score', value: gamerScore },
	// { key: 'avatar_url', value: avatarImageUrl },
	]
	}

	module.exports = fetch
	# Tidbyt Xbox Live App
	# MIT License
	# by Nicholas Penree, Dec 29 2021

	load("render.star", "render")
	load("http.star", "http")
	load("encoding/base64.star", "base64")
	load("cache.star", "cache")

	MOCK=False

	def get_config(config):
	if MOCK:
	return dict(
	gamer_tag = "conceiteddrudge",
	gamer_score = "10808",
	)
	return config

	def GamerScoreLogo():
	return render.Circle(
	color = "#fff",
	diameter = 13,
	child = render.Text(
	content = "G",
	color = "#000",
	font = "Dina_r400-6"
	),
	)

	def GamerScore(gamer_score):
	return render.Row(
	expanded=True,
	main_align="center",
	cross_align="center",
	children = [
	GamerScoreLogo(),
	render.Box(width = 1),
	render.Text(content = gamer_score),
	],
	)

	def main(config):
	settings = get_config(config)
	gamer_tag = settings.get('gamer_tag', '')
	gamer_score = settings.get('gamer_score', '')
	avatar_url = settings.get('avatar_url', '')
	children = []

	if avatar_url != '':
	children += [
	render.Box(height = 2),
	render.Image(src=http.get(avatar_url).body(), height=14, width=14)
	]

	children += [ GamerScore(gamer_score) ]

	if gamer_tag != '':
	if settings.get('scroll', False) or len(gamer_tag) > 8:
	gamer_tag_child = render.Marquee(
	width = 64,
	child = render.Text(color = '#3c3c3c', content = gamer_tag),
	)
	else:
	gamer_tag_child = render.Text(color = '#3c3c3c', content = gamer_tag)
	children += [ gamer_tag_child ]

	return render.Root(
	child = render.Box(
	render.Column(
	expanded=True,
	main_align="center",
	cross_align="center",
	children = children,
	),
	),
	)