row_id
int64 0
48.4k
| init_message
stringlengths 1
342k
| conversation_hash
stringlengths 32
32
| scores
dict |
|---|---|---|---|
44,377
|
If I have a effect in react app using react effector library then how do I throttle the execution of request inside of it using lodash throttle with the time being 1 second?
|
1e194d2ed4d71bb5a303d22f9145d02d
|
{
"intermediate": 0.7912707924842834,
"beginner": 0.07429318130016327,
"expert": 0.13443604111671448
}
|
44,378
|
in datatables library i want to iterate through rows using this expected_fields = [row['FIELD'] for row in self.data_controller_table if row['TABLE'] == table_name] but row value is returned as a column and not a row raising the error column TABLE is not in frmae
|
f04c9dae900c180f6a2cbf2d2fcba34d
|
{
"intermediate": 0.8250859379768372,
"beginner": 0.08846373856067657,
"expert": 0.08645027875900269
}
|
44,379
|
i am using DATATABLE library i want to iterate through rows using this expected_fields = [row[‘FIELD’] for row in self.data_controller_table if row[‘TABLE’] == table_name] but row value is returned as a column and not a row raising the error column TABLE is not in frmae
|
0f6e2282a4e4553b3b9a68274c72de5c
|
{
"intermediate": 0.8202236294746399,
"beginner": 0.0869494155049324,
"expert": 0.0928269624710083
}
|
44,380
|
If I have a effect in react app using react effector library then how do I throttle the execution of request inside of it using patronum throttle with the time being 1 second?
|
e7a5cde15524b4b7b6590ab83b6182a9
|
{
"intermediate": 0.7700664401054382,
"beginner": 0.07258553802967072,
"expert": 0.15734805166721344
}
|
44,381
|
optimize sentence: clarification on NRR-580 requirement
|
229b7c245f573e01011b266768e6bd3e
|
{
"intermediate": 0.2407265305519104,
"beginner": 0.31689783930778503,
"expert": 0.4423755705356598
}
|
44,382
|
is there a way to know if the fx browser is open and to set the focus on it's search box if it is, in reaper lua script
|
15e64a55b888155a9d89cc619bc7a466
|
{
"intermediate": 0.49186915159225464,
"beginner": 0.17029444873332977,
"expert": 0.337836354970932
}
|
44,383
|
Can you write me a simple python code to take 2 inputs x and y, and compute the following and print the results?
The first one is ((1+(x/100)) * 5,747 * 1000000) - ( ((1+(x/100)) * 5,747 * 1000000) - 7404952,26 - 3000000)*0,4 - 982000
and the second one is (1 + ((y - 1) * 0,9)) * 1000000
|
84e473f73ca407be46f7336214375752
|
{
"intermediate": 0.4493509829044342,
"beginner": 0.2376876026391983,
"expert": 0.3129614293575287
}
|
44,384
|
public static void SendHudText(int clientindex, string message, HudTextParams textparams){
lock (ScriptContext.GlobalScriptContext.Lock) {
ScriptContext.GlobalScriptContext.Reset();
ScriptContext.GlobalScriptContext.Push(clientindex);
ScriptContext.GlobalScriptContext.Push(message);
ScriptContext.GlobalScriptContext.Push(textparams);
ScriptContext.GlobalScriptContext.SetIdentifier(0xB0B30EDD);
ScriptContext.GlobalScriptContext.Invoke();
ScriptContext.GlobalScriptContext.CheckErrors();
}
}
public struct HudTextParams()
{
public required float X { get; set; }
public required float Y { get; set; }
public required float HoldTime { get; set; }
public int Effect { get; set; } = 0;
public byte R1 { get; set; }
public byte G1 { get; set; }
public byte B1 { get; set; }
public byte A1 { get; set; }
public byte R2 { get; set; } = 0;
public byte G2 { get; set; } = 0;
public byte B2 { get; set; } = 0;
public byte A2 { get; set; } = 0;
public float FadeinTime { get; set; } = 0.1f;
public float FadeoutTime { get; set; } = 0.2f;
public float FxTime { get; set; } = 6.0f;
public int Channel { get; set; } = 0;
public bool IsSet { get; set; } = false;
}
как мне принимать эти данные в C++?
/*
* This file is part of CounterStrikeSharp.
* CounterStrikeSharp 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.
*
* CounterStrikeSharp 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 CounterStrikeSharp. If not, see <https://www.gnu.org/licenses/>. *
*/
#include <ios>
#include "core/log.h"
#include "protobuf/generated/cstrike15_usermessages.pb.h"
#include <igameeventsystem.h>
#include <networksystem/inetworkserializer.h>
#include <networksystem/inetworkmessages.h>
#include "scripting//callback_manager.h"
#include "scripting/autonative.h"
#include "scripting/script_engine.h"
#include "natives_hudtext.h"
namespace counterstrikesharp
{
void SendHudText(ScriptContext& script_context)
{
auto client = script_context.GetArgument<int>(0);
auto message = script_context.GetArgument<const char*>(1);
auto params = script_context.GetArgument<hud_text_parms>(2);
CSSHARP_CORE_INFO("{0}, {1}, {2}", client, message, params.a1);
static INetworkSerializable* message_type = globals::networkMessages->FindNetworkMessagePartial("CCSUsrMsg_HudMsg");
CCSUsrMsg_HudMsg msg;
msg.set_channel(params.channel & 0xFF);
CMsgVector2D* pos = msg.mutable_pos();
pos->set_x(params.x);
pos->set_y(params.y);
CMsgRGBA* color1 = msg.mutable_clr1();
color1->set_r(params.r1);
color1->set_g(params.g1);
color1->set_b(params.b1);
color1->set_a(params.a1);
CMsgRGBA* color2 = msg.mutable_clr2();
color2->set_r(params.r2);
color2->set_g(params.g2);
color2->set_b(params.b2);
color2->set_a(params.a2);
msg.set_effect(params.effect);
msg.set_fade_in_time(params.fadeinTime);
msg.set_fade_out_time(params.fadeoutTime);
msg.set_hold_time(params.holdTime);
msg.set_fx_time(params.fxTime);
msg.set_text(message);
CRecipientFilter filter;
CPlayerSlot PlayerSlot(client);
filter.AddRecipient(PlayerSlot);
globals::gameEventSystem->PostEventAbstract(0, false, &filter, message_type, &message, 0);
}
REGISTER_NATIVES(hudtext, {
ScriptEngine::RegisterNativeHandler("SEND_HUD_TEXT", SendHudText);
})
} // namespace counterstrikesharp
|
3e15a67c9206531995cab373a939dcd2
|
{
"intermediate": 0.36630281805992126,
"beginner": 0.33078786730766296,
"expert": 0.30290931463241577
}
|
44,385
|
How do i implement ocr on files with Budibase?
|
05c06028fd234d38e7ec887c8255eb42
|
{
"intermediate": 0.5670393109321594,
"beginner": 0.06168214604258537,
"expert": 0.3712784945964813
}
|
44,386
|
hi
|
ef5fd892ffcaa48b191e40ae803581b7
|
{
"intermediate": 0.3246487081050873,
"beginner": 0.27135494351387024,
"expert": 0.40399640798568726
}
|
44,387
|
axum match all route
|
2b99436459c703ef23e7b8edfbe4fc9a
|
{
"intermediate": 0.2556101083755493,
"beginner": 0.3900451958179474,
"expert": 0.3543447256088257
}
|
44,388
|
Some of these rules broke my Qemu DHCP addreses resolution and nat routing .Please help ! IPTABLES="/sbin/iptables"
IP6TABLES="/sbin/ip6tables"
MODPROBE="/sbin/modprobe"
RMMOD="/sbin/rmmod"
ARP="/usr/sbin/arp"
LOG="LOG --log-level debug --log-tcp-sequence --log-tcp-options"
LOG="$LOG --log-ip-options"
RLIMIT="-m limit --limit 3/s --limit-burst 8"
PHIGH="1024:65535"
PSSH="1000:1023"
$MODPROBE ip_conntrack_ftp
$MODPROBE ip_conntrack_irc
echo 1 > /proc/sys/net/ipv4/ip_forward
echo 0 > /proc/sys/net/ipv4/ip_forward
for i in /proc/sys/net/ipv4/conf/*/rp_filter; do echo 1 > $i; done
echo 1 > /proc/sys/net/ipv4/tcp_syncookies
echo 0 > /proc/sys/net/ipv4/icmp_echo_ignore_all
echo 1 > /proc/sys/net/ipv4/icmp_echo_ignore_broadcasts
for i in /proc/sys/net/ipv4/conf/*/log_martians; do echo 1 > $i; done
echo 1 > /proc/sys/net/ipv4/icmp_ignore_bogus_error_responses
for i in /proc/sys/net/ipv4/conf/*/accept_redirects; do echo 0 > $i; done
for i in /proc/sys/net/ipv4/conf/*/send_redirects; do echo 0 > $i; done
for i in /proc/sys/net/ipv4/conf/*/accept_source_route; do echo 0 > $i; done
for i in /proc/sys/net/ipv4/conf/*/proxy_arp; do echo 0 > $i; done
for i in /proc/sys/net/ipv4/conf/*/secure_redirects; do echo 1 > $i; done
for i in /proc/sys/net/ipv4/conf/*/bootp_relay; do echo 0 > $i; done
$IPTABLES -P INPUT DROP
$IPTABLES -P FORWARD DROP
$IPTABLES -P OUTPUT DROP
$IPTABLES -t nat -P PREROUTING ACCEPT
$IPTABLES -t nat -P OUTPUT ACCEPT
$IPTABLES -t nat -P POSTROUTING ACCEPT
$IPTABLES -t mangle -P PREROUTING ACCEPT
$IPTABLES -t mangle -P INPUT ACCEPT
$IPTABLES -t mangle -P FORWARD ACCEPT
$IPTABLES -t mangle -P OUTPUT ACCEPT
$IPTABLES -t mangle -P POSTROUTING ACCEPT
$IPTABLES -F
$IPTABLES -t nat -F
$IPTABLES -t mangle -F
$IPTABLES -X
$IPTABLES -t nat -X
$IPTABLES -t mangle -X
$IPTABLES -Z
$IPTABLES -t nat -Z
$IPTABLES -t mangle -Z
if test -x $IP6TABLES; then
$IP6TABLES -P INPUT DROP 2>/dev/null
$IP6TABLES -P FORWARD DROP 2>/dev/null
$IP6TABLES -P OUTPUT DROP 2>/dev/null
$IP6TABLES -t mangle -P PREROUTING ACCEPT 2>/dev/null
$IP6TABLES -t mangle -P INPUT ACCEPT 2>/dev/null
$IP6TABLES -t mangle -P FORWARD ACCEPT 2>/dev/null
$IP6TABLES -t mangle -P OUTPUT ACCEPT 2>/dev/null
$IP6TABLES -t mangle -P POSTROUTING ACCEPT 2>/dev/null
$IP6TABLES -F 2>/dev/null
$IP6TABLES -t mangle -F 2>/dev/null
$IP6TABLES -X 2>/dev/null
$IP6TABLES -t mangle -X 2>/dev/null
$IP6TABLES -Z 2>/dev/null
$IP6TABLES -t mangle -Z 2>/dev/null
fi
$IPTABLES -N ACCEPTLOG
$IPTABLES -A ACCEPTLOG -j $LOG $RLIMIT --log-prefix "ACCEPT "
$IPTABLES -A ACCEPTLOG -j ACCEPT
$IPTABLES -N DROPLOG
$IPTABLES -A DROPLOG -j $LOG $RLIMIT --log-prefix "DROP "
$IPTABLES -A DROPLOG -j DROP
$IPTABLES -N REJECTLOG
$IPTABLES -A REJECTLOG -j $LOG $RLIMIT --log-prefix "REJECT "
$IPTABLES -A REJECTLOG -p tcp -j REJECT --reject-with tcp-reset
$IPTABLES -A REJECTLOG -j REJECT
$IPTABLES -N RELATED_ICMP
$IPTABLES -A RELATED_ICMP -p icmp --icmp-type destination-unreachable -j ACCEPT
$IPTABLES -A RELATED_ICMP -p icmp --icmp-type time-exceeded -j ACCEPT
$IPTABLES -A RELATED_ICMP -p icmp --icmp-type parameter-problem -j ACCEPT
$IPTABLES -A RELATED_ICMP -j DROPLOG
$IPTABLES -A INPUT -p icmp --fragment -j DROPLOG
$IPTABLES -A OUTPUT -p icmp --fragment -j DROPLOG
$IPTABLES -A FORWARD -p icmp --fragment -j DROPLOG
$IPTABLES -A INPUT -p icmp -m state --state ESTABLISHED -j ACCEPT $RLIMIT
$IPTABLES -A OUTPUT -p icmp -m state --state ESTABLISHED -j ACCEPT $RLIMIT
$IPTABLES -A INPUT -p icmp -m state --state RELATED -j RELATED_ICMP $RLIMIT
$IPTABLES -A OUTPUT -p icmp -m state --state RELATED -j RELATED_ICMP $RLIMIT
$IPTABLES -A INPUT -p icmp --icmp-type echo-request -j ACCEPT $RLIMIT
$IPTABLES -A OUTPUT -p icmp --icmp-type echo-request -j ACCEPT $RLIMIT
$IPTABLES -A INPUT -p icmp -j DROPLOG
$IPTABLES -A OUTPUT -p icmp -j DROPLOG
$IPTABLES -A FORWARD -p icmp -j DROPLOG
$IPTABLES -A INPUT -i lo -j ACCEPT
$IPTABLES -A OUTPUT -o lo -j ACCEPT
$IPTABLES -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
$IPTABLES -A OUTPUT -m state --state NEW,ESTABLISHED,RELATED -j ACCEPT
$IPTABLES -A INPUT -p tcp -m multiport \
--dports 135,137,138,139,445,1433,1434 -j DROP
$IPTABLES -A INPUT -p udp -m multiport \
--dports 135,137,138,139,445,1433,1434 -j DROP
$IPTABLES -A INPUT -m state --state INVALID -j DROP
$IPTABLES -A OUTPUT -m state --state INVALID -j DROP
$IPTABLES -A FORWARD -m state --state INVALID -j DROP
$IPTABLES -A INPUT -m state --state NEW -p tcp --tcp-flags ALL ALL -j DROP
$IPTABLES -A INPUT -m state --state NEW -p tcp --tcp-flags ALL NONE -j DROP
$IPTABLES -A INPUT -s 0.0.0.0/7 -j DROP
$IPTABLES -A INPUT -s 2.0.0.0/8 -j DROP
$IPTABLES -A INPUT -s 5.0.0.0/8 -j DROP
$IPTABLES -A INPUT -s 7.0.0.0/8 -j DROP
$IPTABLES -A INPUT -s 10.0.0.0/8 -j DROP
$IPTABLES -A INPUT -s 23.0.0.0/8 -j DROP
$IPTABLES -A INPUT -s 27.0.0.0/8 -j DROP
$IPTABLES -A INPUT -s 31.0.0.0/8 -j DROP
$IPTABLES -A INPUT -s 36.0.0.0/7 -j DROP
$IPTABLES -A INPUT -s 39.0.0.0/8 -j DROP
$IPTABLES -A INPUT -s 42.0.0.0/8 -j DROP
$IPTABLES -A INPUT -s 49.0.0.0/8 -j DROP
$IPTABLES -A INPUT -s 50.0.0.0/8 -j DROP
$IPTABLES -A INPUT -s 77.0.0.0/8 -j DROP
$IPTABLES -A INPUT -s 78.0.0.0/7 -j DROP
$IPTABLES -A INPUT -s 92.0.0.0/6 -j DROP
$IPTABLES -A INPUT -s 96.0.0.0/4 -j DROP
$IPTABLES -A INPUT -s 112.0.0.0/5 -j DROP
$IPTABLES -A INPUT -s 120.0.0.0/8 -j DROP
$IPTABLES -A INPUT -s 169.254.0.0/16 -j DROP
$IPTABLES -A INPUT -s 172.16.0.0/12 -j DROP
$IPTABLES -A INPUT -s 173.0.0.0/8 -j DROP
$IPTABLES -A INPUT -s 174.0.0.0/7 -j DROP
$IPTABLES -A INPUT -s 176.0.0.0/5 -j DROP
$IPTABLES -A INPUT -s 184.0.0.0/6 -j DROP
$IPTABLES -A INPUT -s 192.0.2.0/24 -j DROP
$IPTABLES -A INPUT -s 197.0.0.0/8 -j DROP
$IPTABLES -A INPUT -s 198.18.0.0/15 -j DROP
$IPTABLES -A INPUT -s 223.0.0.0/8 -j DROP
$IPTABLES -A INPUT -s 224.0.0.0/3 -j DROP
$IPTABLES -A INPUT -j REJECTLOG
$IPTABLES -A OUTPUT -j REJECTLOG
$IPTABLES -A FORWARD -j REJECTLOG
exit 0
|
f1b445572ca0d953d56975d17d9e10e0
|
{
"intermediate": 0.3597862124443054,
"beginner": 0.3463042676448822,
"expert": 0.2939095199108124
}
|
44,389
|
some of this rules broke my Qemu DHCP and NAT routing : IPTABLES="/sbin/iptables"
IP6TABLES="/sbin/ip6tables"
MODPROBE="/sbin/modprobe"
RMMOD="/sbin/rmmod"
ARP="/usr/sbin/arp"
LOG="LOG --log-level debug --log-tcp-sequence --log-tcp-options"
LOG="$LOG --log-ip-options"
RLIMIT="-m limit --limit 3/s --limit-burst 8"
PHIGH="1024:65535"
PSSH="1000:1023"
$MODPROBE ip_conntrack_ftp
$MODPROBE ip_conntrack_irc
echo 1 > /proc/sys/net/ipv4/ip_forward
echo 0 > /proc/sys/net/ipv4/ip_forward
for i in /proc/sys/net/ipv4/conf/*/rp_filter; do echo 1 > $i; done
echo 1 > /proc/sys/net/ipv4/tcp_syncookies
echo 0 > /proc/sys/net/ipv4/icmp_echo_ignore_all
echo 1 > /proc/sys/net/ipv4/icmp_echo_ignore_broadcasts
for i in /proc/sys/net/ipv4/conf/*/log_martians; do echo 1 > $i; done
echo 1 > /proc/sys/net/ipv4/icmp_ignore_bogus_error_responses
for i in /proc/sys/net/ipv4/conf/*/accept_redirects; do echo 0 > $i; done
for i in /proc/sys/net/ipv4/conf/*/send_redirects; do echo 0 > $i; done
for i in /proc/sys/net/ipv4/conf/*/accept_source_route; do echo 0 > $i; done
for i in /proc/sys/net/ipv4/conf/*/proxy_arp; do echo 0 > $i; done
for i in /proc/sys/net/ipv4/conf/*/secure_redirects; do echo 1 > $i; done
for i in /proc/sys/net/ipv4/conf/*/bootp_relay; do echo 0 > $i; done
$IPTABLES -P INPUT DROP
$IPTABLES -P FORWARD DROP
$IPTABLES -P OUTPUT DROP
$IPTABLES -t nat -P PREROUTING ACCEPT
$IPTABLES -t nat -P OUTPUT ACCEPT
$IPTABLES -t nat -P POSTROUTING ACCEPT
$IPTABLES -t mangle -P PREROUTING ACCEPT
$IPTABLES -t mangle -P INPUT ACCEPT
$IPTABLES -t mangle -P FORWARD ACCEPT
$IPTABLES -t mangle -P OUTPUT ACCEPT
$IPTABLES -t mangle -P POSTROUTING ACCEPT
$IPTABLES -F
$IPTABLES -t nat -F
$IPTABLES -t mangle -F
$IPTABLES -X
$IPTABLES -t nat -X
$IPTABLES -t mangle -X
$IPTABLES -Z
$IPTABLES -t nat -Z
$IPTABLES -t mangle -Z
if test -x $IP6TABLES; then
$IP6TABLES -P INPUT DROP 2>/dev/null
$IP6TABLES -P FORWARD DROP 2>/dev/null
$IP6TABLES -P OUTPUT DROP 2>/dev/null
$IP6TABLES -t mangle -P PREROUTING ACCEPT 2>/dev/null
$IP6TABLES -t mangle -P INPUT ACCEPT 2>/dev/null
$IP6TABLES -t mangle -P FORWARD ACCEPT 2>/dev/null
$IP6TABLES -t mangle -P OUTPUT ACCEPT 2>/dev/null
$IP6TABLES -t mangle -P POSTROUTING ACCEPT 2>/dev/null
$IP6TABLES -F 2>/dev/null
$IP6TABLES -t mangle -F 2>/dev/null
$IP6TABLES -X 2>/dev/null
$IP6TABLES -t mangle -X 2>/dev/null
$IP6TABLES -Z 2>/dev/null
$IP6TABLES -t mangle -Z 2>/dev/null
fi
$IPTABLES -N ACCEPTLOG
$IPTABLES -A ACCEPTLOG -j $LOG $RLIMIT --log-prefix "ACCEPT "
$IPTABLES -A ACCEPTLOG -j ACCEPT
$IPTABLES -N DROPLOG
$IPTABLES -A DROPLOG -j $LOG $RLIMIT --log-prefix "DROP "
$IPTABLES -A DROPLOG -j DROP
$IPTABLES -N REJECTLOG
$IPTABLES -A REJECTLOG -j $LOG $RLIMIT --log-prefix "REJECT "
$IPTABLES -A REJECTLOG -p tcp -j REJECT --reject-with tcp-reset
$IPTABLES -A REJECTLOG -j REJECT
$IPTABLES -N RELATED_ICMP
$IPTABLES -A RELATED_ICMP -p icmp --icmp-type destination-unreachable -j ACCEPT
$IPTABLES -A RELATED_ICMP -p icmp --icmp-type time-exceeded -j ACCEPT
$IPTABLES -A RELATED_ICMP -p icmp --icmp-type parameter-problem -j ACCEPT
$IPTABLES -A RELATED_ICMP -j DROPLOG
$IPTABLES -A INPUT -p icmp --fragment -j DROPLOG
$IPTABLES -A OUTPUT -p icmp --fragment -j DROPLOG
$IPTABLES -A FORWARD -p icmp --fragment -j DROPLOG
$IPTABLES -A INPUT -p icmp -m state --state ESTABLISHED -j ACCEPT $RLIMIT
$IPTABLES -A OUTPUT -p icmp -m state --state ESTABLISHED -j ACCEPT $RLIMIT
$IPTABLES -A INPUT -p icmp -m state --state RELATED -j RELATED_ICMP $RLIMIT
$IPTABLES -A OUTPUT -p icmp -m state --state RELATED -j RELATED_ICMP $RLIMIT
$IPTABLES -A INPUT -p icmp --icmp-type echo-request -j ACCEPT $RLIMIT
$IPTABLES -A OUTPUT -p icmp --icmp-type echo-request -j ACCEPT $RLIMIT
$IPTABLES -A INPUT -p icmp -j DROPLOG
$IPTABLES -A OUTPUT -p icmp -j DROPLOG
$IPTABLES -A FORWARD -p icmp -j DROPLOG
$IPTABLES -A INPUT -i lo -j ACCEPT
$IPTABLES -A OUTPUT -o lo -j ACCEPT
$IPTABLES -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
$IPTABLES -A OUTPUT -m state --state NEW,ESTABLISHED,RELATED -j ACCEPT
$IPTABLES -A INPUT -p tcp -m multiport \
--dports 135,137,138,139,445,1433,1434 -j DROP
$IPTABLES -A INPUT -p udp -m multiport \
--dports 135,137,138,139,445,1433,1434 -j DROP
$IPTABLES -A INPUT -m state --state INVALID -j DROP
$IPTABLES -A OUTPUT -m state --state INVALID -j DROP
$IPTABLES -A FORWARD -m state --state INVALID -j DROP
$IPTABLES -A INPUT -m state --state NEW -p tcp --tcp-flags ALL ALL -j DROP
$IPTABLES -A INPUT -m state --state NEW -p tcp --tcp-flags ALL NONE -j DROP
$IPTABLES -A INPUT -s 0.0.0.0/7 -j DROP
$IPTABLES -A INPUT -s 2.0.0.0/8 -j DROP
$IPTABLES -A INPUT -s 5.0.0.0/8 -j DROP
$IPTABLES -A INPUT -s 7.0.0.0/8 -j DROP
$IPTABLES -A INPUT -s 10.0.0.0/8 -j DROP
$IPTABLES -A INPUT -s 23.0.0.0/8 -j DROP
$IPTABLES -A INPUT -s 27.0.0.0/8 -j DROP
$IPTABLES -A INPUT -s 31.0.0.0/8 -j DROP
$IPTABLES -A INPUT -s 36.0.0.0/7 -j DROP
$IPTABLES -A INPUT -s 39.0.0.0/8 -j DROP
$IPTABLES -A INPUT -s 42.0.0.0/8 -j DROP
$IPTABLES -A INPUT -s 49.0.0.0/8 -j DROP
$IPTABLES -A INPUT -s 50.0.0.0/8 -j DROP
$IPTABLES -A INPUT -s 77.0.0.0/8 -j DROP
$IPTABLES -A INPUT -s 78.0.0.0/7 -j DROP
$IPTABLES -A INPUT -s 92.0.0.0/6 -j DROP
$IPTABLES -A INPUT -s 96.0.0.0/4 -j DROP
$IPTABLES -A INPUT -s 112.0.0.0/5 -j DROP
$IPTABLES -A INPUT -s 120.0.0.0/8 -j DROP
$IPTABLES -A INPUT -s 169.254.0.0/16 -j DROP
$IPTABLES -A INPUT -s 172.16.0.0/12 -j DROP
$IPTABLES -A INPUT -s 173.0.0.0/8 -j DROP
$IPTABLES -A INPUT -s 174.0.0.0/7 -j DROP
$IPTABLES -A INPUT -s 176.0.0.0/5 -j DROP
$IPTABLES -A INPUT -s 184.0.0.0/6 -j DROP
$IPTABLES -A INPUT -s 192.0.2.0/24 -j DROP
$IPTABLES -A INPUT -s 197.0.0.0/8 -j DROP
$IPTABLES -A INPUT -s 198.18.0.0/15 -j DROP
$IPTABLES -A INPUT -s 223.0.0.0/8 -j DROP
$IPTABLES -A INPUT -s 224.0.0.0/3 -j DROP
$IPTABLES -A INPUT -j REJECTLOG
$IPTABLES -A OUTPUT -j REJECTLOG
$IPTABLES -A FORWARD -j REJECTLOG
exit 0
|
a6499bbb60833f0358254115c16147f7
|
{
"intermediate": 0.3610556125640869,
"beginner": 0.3787209689617157,
"expert": 0.260223388671875
}
|
44,390
|
how send table to js in lua script? (defold engine)
|
336fab33d839febde2afa94fea9e2654
|
{
"intermediate": 0.5662130117416382,
"beginner": 0.16115106642246246,
"expert": 0.2726359963417053
}
|
44,391
|
import pygame
import random
import math
# Initialize pygame and create a screen object
pygame.init()
screen = pygame.display.set_mode((1000, 800))
# Define grid size
GRID_WIDTH = 21
GRID_HEIGHT = 17
# Define initial floor position
FLOOR_START_ROW = GRID_HEIGHT - 2
FLOOR_END_ROW = GRID_HEIGHT - 1
pygame.display.set_caption(‘100% no luck’)
# Load the images for the background, the player, and the boss
# Ensure that these images are present in your project directory
try:
background = pygame.image.load(‘level_1_background.jpeg’)
player_image = pygame.image.load(‘player1_back.png’)
invisibility_cloak_image = pygame.image.load(‘invisibility_cloak.png’)
grappling_hook_image = pygame.image.load(‘grappling_hook.png’)
katana_image = pygame.image.load(‘katana.png’)
freezing_ray_image = pygame.image.load(‘freezing_ray.png’)
speed_pill_image = pygame.image.load(‘speed_pill.jpeg’)
bouncy_shoes_image = pygame.image.load(‘bouncy_shoes.png’)
key_image = pygame.image.load(‘key.png’)
tsunami_maker_image = pygame.image.load(‘tsunami_maker.png’)
laser_beam_image = pygame.image.load(‘laser_beam.png’)
go_kart_image = pygame.image.load(‘go_kart.jpeg’)
revival_kit_image = pygame.image.load(‘revival_kit.jpeg’)
except pygame.error as e:
print(“Cannot load images:”, e)
raise SystemExit
# Define the colors for the text
WHITE = (255, 255, 255)
# Define the font for the text
font = pygame.font.SysFont(‘Arial’, 32)
# Define the text for the intro and the tools
intro_text = “Welcome to 100% no luck, a game where you have to use smart logic and some luck to beat the dungeon. You will spawn with 3 tools out of a possible 15 tools randomized. Each tool has a different effect and can help you or hinder you depending on the situation. You have to think carefully about how to use your tools and when to use them. The dungeon has many obstacles and enemies that you have to overcome. The goal is to reach the end of the dungeon and defeat the boss. Good luck!”
tools_text = [“Invisibility cloak: Makes you invisible for 10 seconds. Useful for sneaking past enemies or traps.”,
“Grappling hook: Allows you to swing across gaps or pull objects towards you.”,
“Katana: A sharp sword that can cut through anything. Useful for fighting enemies or breaking barriers.”,
“Freeze ray: A device that can freeze anything in its path. Useful for stopping enemies or creating platforms.”,
“Bouncy shoes: Shoes that make you jump higher and farther. Useful for reaching high places or avoiding obstacles.”,
“Key: A key that can unlock any door or chest. Useful for accessing hidden areas or treasures.”,
“Go kart: A vehicle that can move fast and run over anything. Useful for escaping enemies or crossing large distances.”,
“Tsunami maker: A device that can create a huge wave of water. Useful for washing away enemies or filling gaps.”,
“Laser beam: A device that can shoot a powerful laser. Useful for destroying enemies or barriers.”,
“Speed pill: A pill that can make you move faster for 10 seconds. Useful for dodging enemies or traps.”,
“Revival kit: A kit that can revive you once if you die. Useful for surviving fatal situations.”]
def show_intro():
intro_text = “Welcome to 100% no luck, a game where you have to use smart logic and some luck to beat the dungeon. You will spawn with 3 tools out of a possible 15 tools randomized. Each tool has a different effect and can help you or hinder you depending on the situation. You have to think carefully about how to use your tools and when to use them. The dungeon has many obstacles and enemies that you have to overcome. The goal is to reach the end of the dungeon and defeat the boss. Good luck!”
# Wrap the intro text
intro_lines = []
max_width = 950 # Adjust as needed
words = intro_text.split()
current_line = words[0]
for word in words[1:]:
if font.size(current_line + ’ ’ + word)[0] < max_width:
current_line += ’ ’ + word
else:
intro_lines.append(current_line)
current_line = word
intro_lines.append(current_line)
current_line = 0
intro_complete = False
start_time = pygame.time.get_ticks()
while not intro_complete:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
screen.fill((0, 0, 0))
intro_surface = font.render(intro_lines[current_line], True, WHITE)
intro_rect = intro_surface.get_rect(center=(screen.get_width() // 2, screen.get_height() // 2))
screen.blit(intro_surface, intro_rect)
if pygame.time.get_ticks() - start_time > 2980:
current_line += 1
start_time = pygame.time.get_ticks()
if current_line == len(intro_lines):
intro_complete = True
pygame.display.flip()
pygame.time.Clock().tick(60)
screen.fill((0, 0, 0))
pygame.display.flip()
tools_title_surface = font.render(“Selected Tools:”, True, WHITE)
tools_title_rect = tools_title_surface.get_rect(center=(screen.get_width() // 2, 100))
screen.blit(tools_title_surface, tools_title_rect)
pygame.display.flip()
pygame.time.delay(1000)
selected_tools = random.sample(tools_text, 3)
# Wrap the tool descriptions
wrapped_tools = []
for tool_desc in selected_tools:
tool_lines = []
current_line = tool_desc.split()[0]
for word in tool_desc.split()[1:]:
if font.size(current_line + ’ ’ + word)[0] < max_width:
current_line += ’ ’ + word
else:
tool_lines.append(current_line)
current_line = word
tool_lines.append(current_line)
wrapped_tools.append(tool_lines)
selected_tools_surface = [font.render(line, True, WHITE) for tool_lines in wrapped_tools for line in tool_lines]
for i, tool_surface in enumerate(selected_tools_surface):
tool_rect = tool_surface.get_rect(center=(screen.get_width() // 2, 200 + i * 50))
screen.blit(tool_surface, tool_rect)
pygame.display.flip()
start_time = pygame.time.get_ticks()
while pygame.time.get_ticks() - start_time < 2000:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
screen.fill((0, 0, 0))
pygame.display.flip()
# Define the logic for each tool as a function
def invisibility_cloak():
# Set a global variable to indicate that the player is invisible
global invisible
invisible = True
# Set a timer to make the player visible again after 10 seconds
pygame.time.set_timer(pygame.USEREVENT, 10000)
def grappling_hook():
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the distance and the angle between the mouse and the player
distance = ((mouse_x - player_x) ** 2 + (mouse_y - player_y) ** 2) ** 0.5
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, BLACK, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the mouse is over a gap or an object
if mouse_x > 600 and mouse_x < 700 and mouse_y > 300 and mouse_y < 400:
# If the mouse is over a gap, move the player towards the mouse
player_rect.centerx += math.cos(angle) * 10
player_rect.centery += math.sin(angle) * 10
elif mouse_x > 700 and mouse_x < 800 and mouse_y > 200 and mouse_y < 300:
# If the mouse is over an object, move the object towards the player
object_rect.centerx -= math.cos(angle) * 10
object_rect.centery -= math.sin(angle) * 10
def katana():
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the angle between the mouse and the player
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, RED, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the line intersects with an enemy or a barrier
if pygame.sprite.spritecollideany(line, enemies) or pygame.sprite.spritecollideany(line, barriers):
# If the line intersects with an enemy or a barrier, destroy it
pygame.sprite.spritecollide(line, enemies, True)
pygame.sprite.spritecollide(line, barriers, True)
def bouncy_shoes():
# Set a global variable to indicate that the player has bouncy shoes
global bouncy
bouncy = True
# Increase the player’s jump velocity
player_jump_vel = 20
def key():
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the distance between the mouse and the player
distance = ((mouse_x - player_x) ** 2 + (mouse_y - player_y) ** 2) ** 0.5
# Check if the mouse is over a door or a chest
if pygame.sprite.spritecollideany(mouse, doors) or pygame.sprite.spritecollideany(mouse, chests):
# If the mouse is over a door or a chest, unlock it and open it
pygame.sprite.spritecollide(mouse, doors, True)
pygame.sprite.spritecollide(mouse, chests, True)
# If the chest contains a tool, add it to the player’s inventory
if chest.tool:
inventory.append(chest.tool)
def go_kart():
# Set a global variable to indicate that the player is in a go kart
global go_kart
go_kart = True
# Increase the player’s speed and size
player_speed = 15
player_rect.inflate_ip(50, 50)
# Load the image for the go kart
go_kart = pygame.image.load(‘go_kart.png’)
# Draw the go kart over the player
screen.blit(go_kart, player_rect)
# Check if the player collides with an enemy or a barrier
if pygame.sprite.spritecollideany(player, enemies) or pygame.sprite.spritecollideany(player, barriers):
# If the player collides with an enemy or a barrier, run over it and destroy it
pygame.sprite.spritecollide(player, enemies, True)
pygame.sprite.spritecollide(player, barriers, True)
def freeze_ray():
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the angle between the mouse and the player
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, BLUE, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the line intersects with an enemy or a platform
if pygame.sprite.spritecollideany(line, enemies) or pygame.sprite.spritecollideany(line, platforms):
# If the line intersects with an enemy or a platform, freeze it
pygame.sprite.spritecollide(line, enemies, False, freeze)
pygame.sprite.spritecollide(line, platforms, False, freeze)
def freeze(sprite):
# Change the sprite’s image to a frozen version
sprite.image = pygame.image.load(sprite.name + ‘_frozen.png’)
# Set the sprite’s frozen attribute to True
sprite.frozen = True
def tsunami_maker():
# Set a global variable to indicate that the player has used the tsunami maker
global tsunami
tsunami = True
# Load the image for the wave
wave = pygame.image.load(‘wave.png’)
# Create a rect for the wave
wave_rect = wave.get_rect()
# Set the wave’s initial position at the left edge of the screen
wave_rect.left = 0
# Set the wave’s speed
wave_speed = 10
# Draw the wave on the screen
screen.blit(wave, wave_rect)
# Move the wave to the right
wave_rect.x += wave_speed
# Check if the wave collides with an enemy or a gap
if pygame.sprite.spritecollideany(wave, enemies) or pygame.sprite.spritecollideany(wave, gaps):
# If the wave collides with an enemy or a gap, wash it away
pygame.sprite.spritecollide(wave, enemies, True)
pygame.sprite.spritecollide(wave, gaps, True, fill)
def fill(sprite):
# Change the sprite’s image to a water version
sprite.image = pygame.image.load(sprite.name + ‘_water.png’)
# Set the sprite’s filled attribute to True
sprite.filled = True
def laser_beam():
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the angle between the mouse and the player
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, YELLOW, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the line intersects with an enemy or a barrier
if pygame.sprite.spritecollideany(line, enemies) or pygame.sprite.spritecollideany(line, barriers):
# If the line intersects with an enemy or a barrier, destroy it
pygame.sprite.spritecollide(line, enemies, True)
pygame.sprite.spritecollide(line, barriers, True)
def speed_pill():
# Set a global variable to indicate that the player has used the speed pill
global speed
speed = True
# Set a timer to make the player normal again after 10 seconds
pygame.time.set_timer(pygame.USEREVENT + 1, 10000)
# Increase the player’s speed
player_speed = 10
def revival_kit():
# Set a global variable to indicate that the player has a revival kit
global revival
revival = True
# Check if the player’s health is zero
if player_health == 0:
# If the player’s health is zero, revive the player
player_health = 100
# Set the revival variable to False
revival = False
def is_on_floor_or_stairs(player_rect):
“”“
Check if the player is standing on a floor or stairs cell.
Returns True if standing on floor or stairs, False otherwise.
“””
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Check if the player is on the initial floor rows
if FLOOR_START_ROW <= player_rect.bottom // cell_height <= FLOOR_END_ROW:
for x in range(player_rect.left // cell_width, (player_rect.right + cell_width - 1) // cell_width):
if 0 <= x < GRID_WIDTH:
return True
return False
def draw_doors():
# Define the door’s color
DOOR_COLOR = (139, 69, 19) # Saddle brown color
# Calculate the cell size based on the screen dimensions
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Draw door 1
door1_start_row = GRID_HEIGHT - 10
door1_end_row = GRID_HEIGHT - 13
door1_start_col = 10
door1_end_col = 11
for row in range(door1_start_row, door1_end_row - 1, -1):
for col in range(door1_start_col, door1_end_col + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, DOOR_COLOR, rect)
# Draw door 2
door2_start_row = GRID_HEIGHT - 3
door2_end_row = GRID_HEIGHT - 4
door2_start_col = 16
door2_end_col = 17
for row in range(door2_start_row, door2_end_row - 1, -1):
for col in range(door2_start_col, door2_end_col + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, DOOR_COLOR, rect)
def draw_floor():
# Define the floor’s color
FLOOR_COLOR = (128, 64, 0) # Brown color
STAIRS_COLOR = (128, 128, 128) # Gray color
# Calculate the cell size based on the screen dimensions
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Draw the floor cells
for col in range(GRID_WIDTH):
for row in range(FLOOR_START_ROW, FLOOR_END_ROW + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, FLOOR_COLOR, rect)
enemies = pygame.sprite.Group()
barriers = pygame.sprite.Group()
platforms = pygame.sprite.Group()
doors = pygame.sprite.Group()
chests = pygame.sprite.Group()
gaps = pygame.sprite.Group()
tools = pygame.sprite.Group()
# Create some sprites and groups for the player
player_sprite = pygame.sprite.Sprite()
player_sprite.image = player_image
player_sprite.rect = player_sprite.image.get_rect()
player_sprite.rect.center = (100, 300)
# Create sprite groups
enemies = pygame.sprite.Group()
tools = pygame.sprite.Group() # Assuming tools are also Sprites
# Gravity constant
GRAVITY = 0.5
# Player properties
player_x = 100
player_y = 300
player_speed = 5
player_jump_vel = 10
player_vert_vel = 0 # Initial vertical velocity
player_health = 100
inventory = []
# Main game loop control
running = True
clock = pygame.time.Clock()
show_intro()
# Initialize player jumping state
player_is_jumping = False
while running:
# 1. Handle events
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE and not player_is_jumping:
# Start jumping
player_is_jumping = True
player_vert_vel = -player_jump_vel
# 2. Update game state
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT]:
player_sprite.rect.x -= player_speed
if keys[pygame.K_RIGHT]:
player_sprite.rect.x += player_speed
if keys[pygame.K_UP]:
player_sprite.rect.y -= player_speed
if keys[pygame.K_DOWN]:
player_sprite.rect.y += player_speed
# Update player’s vertical velocity and position if jumping
if player_is_jumping:
player_vert_vel += GRAVITY
player_sprite.rect.y += player_vert_vel
# Check if the player has landed on floor or stairs
if is_on_floor_or_stairs(player_sprite.rect):
player_is_jumping = False
player_vert_vel = 0
else:
# Apply gravity only if not on floor or stairs
if not is_on_floor_or_stairs(player_sprite.rect):
player_vert_vel += GRAVITY
player_sprite.rect.y += player_vert_vel
# Reset vertical velocity if on floor or stairs
if is_on_floor_or_stairs(player_sprite.rect):
player_vert_vel = 0
# Prevent the player from moving off screen
player_sprite.rect.clamp_ip(screen.get_rect())
# 3. Draw everything
screen.blit(background, (0, 0))
draw_floor()
draw_doors()
tools.draw(screen)
enemies.draw(screen)
screen.blit(player_sprite.image, player_sprite.rect) # Draw player
# After drawing everything, update/flip the display
pygame.display.flip()
# 4. Cap the frame rate
clock.tick(60) first lets assign the 3 randomly selected tools they got at start of game to buttons v,b,n. show relevant parts i need to change or add or update.
|
5968a17f1d4857b640524b3a54fa8e9b
|
{
"intermediate": 0.43946021795272827,
"beginner": 0.3746280372142792,
"expert": 0.18591171503067017
}
|
44,392
|
import pygame
import random
import math
# Initialize pygame and create a screen object
pygame.init()
screen = pygame.display.set_mode((1000, 800))
# Define grid size
GRID_WIDTH = 21
GRID_HEIGHT = 17
# Define initial floor position
FLOOR_START_ROW = GRID_HEIGHT - 2
FLOOR_END_ROW = GRID_HEIGHT - 1
pygame.display.set_caption(‘100% no luck’)
# Load the images for the background, the player, and the boss
# Ensure that these images are present in your project directory
try:
background = pygame.image.load(‘level_1_background.jpeg’)
player_image = pygame.image.load(‘player1_back.png’)
invisibility_cloak_image = pygame.image.load(‘invisibility_cloak.png’)
grappling_hook_image = pygame.image.load(‘grappling_hook.png’)
katana_image = pygame.image.load(‘katana.png’)
freezing_ray_image = pygame.image.load(‘freezing_ray.png’)
speed_pill_image = pygame.image.load(‘speed_pill.jpeg’)
bouncy_shoes_image = pygame.image.load(‘bouncy_shoes.png’)
key_image = pygame.image.load(‘key.png’)
tsunami_maker_image = pygame.image.load(‘tsunami_maker.png’)
laser_beam_image = pygame.image.load(‘laser_beam.png’)
go_kart_image = pygame.image.load(‘go_kart.jpeg’)
revival_kit_image = pygame.image.load(‘revival_kit.jpeg’)
except pygame.error as e:
print(“Cannot load images:”, e)
raise SystemExit
# Define the colors for the text
WHITE = (255, 255, 255)
# Define the font for the text
font = pygame.font.SysFont(‘Arial’, 32)
# Define the text for the intro and the tools
intro_text = “Welcome to 100% no luck, a game where you have to use smart logic and some luck to beat the dungeon. You will spawn with 3 tools out of a possible 15 tools randomized. Each tool has a different effect and can help you or hinder you depending on the situation. You have to think carefully about how to use your tools and when to use them. The dungeon has many obstacles and enemies that you have to overcome. The goal is to reach the end of the dungeon and defeat the boss. Good luck!”
tools_text = [“Invisibility cloak: Makes you invisible for 10 seconds. Useful for sneaking past enemies or traps.”,
“Grappling hook: Allows you to swing across gaps or pull objects towards you.”,
“Katana: A sharp sword that can cut through anything. Useful for fighting enemies or breaking barriers.”,
“Freeze ray: A device that can freeze anything in its path. Useful for stopping enemies or creating platforms.”,
“Bouncy shoes: Shoes that make you jump higher and farther. Useful for reaching high places or avoiding obstacles.”,
“Key: A key that can unlock any door or chest. Useful for accessing hidden areas or treasures.”,
“Go kart: A vehicle that can move fast and run over anything. Useful for escaping enemies or crossing large distances.”,
“Tsunami maker: A device that can create a huge wave of water. Useful for washing away enemies or filling gaps.”,
“Laser beam: A device that can shoot a powerful laser. Useful for destroying enemies or barriers.”,
“Speed pill: A pill that can make you move faster for 10 seconds. Useful for dodging enemies or traps.”,
“Revival kit: A kit that can revive you once if you die. Useful for surviving fatal situations.”]
def show_intro():
intro_text = “Welcome to 100% no luck, a game where you have to use smart logic and some luck to beat the dungeon. You will spawn with 3 tools out of a possible 15 tools randomized. Each tool has a different effect and can help you or hinder you depending on the situation. You have to think carefully about how to use your tools and when to use them. The dungeon has many obstacles and enemies that you have to overcome. The goal is to reach the end of the dungeon and defeat the boss. Good luck!”
# Wrap the intro text
intro_lines = []
max_width = 950 # Adjust as needed
words = intro_text.split()
current_line = words[0]
for word in words[1:]:
if font.size(current_line + ’ ’ + word)[0] < max_width:
current_line += ’ ’ + word
else:
intro_lines.append(current_line)
current_line = word
intro_lines.append(current_line)
current_line = 0
intro_complete = False
start_time = pygame.time.get_ticks()
while not intro_complete:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
screen.fill((0, 0, 0))
intro_surface = font.render(intro_lines[current_line], True, WHITE)
intro_rect = intro_surface.get_rect(center=(screen.get_width() // 2, screen.get_height() // 2))
screen.blit(intro_surface, intro_rect)
if pygame.time.get_ticks() - start_time > 2980:
current_line += 1
start_time = pygame.time.get_ticks()
if current_line == len(intro_lines):
intro_complete = True
pygame.display.flip()
pygame.time.Clock().tick(60)
screen.fill((0, 0, 0))
pygame.display.flip()
tools_title_surface = font.render(“Selected Tools:”, True, WHITE)
tools_title_rect = tools_title_surface.get_rect(center=(screen.get_width() // 2, 100))
screen.blit(tools_title_surface, tools_title_rect)
pygame.display.flip()
pygame.time.delay(1000)
selected_tools = random.sample(tools_text, 3)
# Wrap the tool descriptions
wrapped_tools = []
for tool_desc in selected_tools:
tool_lines = []
current_line = tool_desc.split()[0]
for word in tool_desc.split()[1:]:
if font.size(current_line + ’ ’ + word)[0] < max_width:
current_line += ’ ’ + word
else:
tool_lines.append(current_line)
current_line = word
tool_lines.append(current_line)
wrapped_tools.append(tool_lines)
selected_tools_surface = [font.render(line, True, WHITE) for tool_lines in wrapped_tools for line in tool_lines]
for i, tool_surface in enumerate(selected_tools_surface):
tool_rect = tool_surface.get_rect(center=(screen.get_width() // 2, 200 + i * 50))
screen.blit(tool_surface, tool_rect)
pygame.display.flip()
start_time = pygame.time.get_ticks()
while pygame.time.get_ticks() - start_time < 2000:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
screen.fill((0, 0, 0))
pygame.display.flip()
# Define the logic for each tool as a function
def invisibility_cloak():
# Set a global variable to indicate that the player is invisible
global invisible
invisible = True
# Set a timer to make the player visible again after 10 seconds
pygame.time.set_timer(pygame.USEREVENT, 10000)
def grappling_hook():
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the distance and the angle between the mouse and the player
distance = ((mouse_x - player_x) ** 2 + (mouse_y - player_y) ** 2) ** 0.5
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, BLACK, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the mouse is over a gap or an object
if mouse_x > 600 and mouse_x < 700 and mouse_y > 300 and mouse_y < 400:
# If the mouse is over a gap, move the player towards the mouse
player_rect.centerx += math.cos(angle) * 10
player_rect.centery += math.sin(angle) * 10
elif mouse_x > 700 and mouse_x < 800 and mouse_y > 200 and mouse_y < 300:
# If the mouse is over an object, move the object towards the player
object_rect.centerx -= math.cos(angle) * 10
object_rect.centery -= math.sin(angle) * 10
def katana():
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the angle between the mouse and the player
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, RED, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the line intersects with an enemy or a barrier
if pygame.sprite.spritecollideany(line, enemies) or pygame.sprite.spritecollideany(line, barriers):
# If the line intersects with an enemy or a barrier, destroy it
pygame.sprite.spritecollide(line, enemies, True)
pygame.sprite.spritecollide(line, barriers, True)
def bouncy_shoes():
# Set a global variable to indicate that the player has bouncy shoes
global bouncy
bouncy = True
# Increase the player’s jump velocity
player_jump_vel = 20
def key():
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the distance between the mouse and the player
distance = ((mouse_x - player_x) ** 2 + (mouse_y - player_y) ** 2) ** 0.5
# Check if the mouse is over a door or a chest
if pygame.sprite.spritecollideany(mouse, doors) or pygame.sprite.spritecollideany(mouse, chests):
# If the mouse is over a door or a chest, unlock it and open it
pygame.sprite.spritecollide(mouse, doors, True)
pygame.sprite.spritecollide(mouse, chests, True)
# If the chest contains a tool, add it to the player’s inventory
if chest.tool:
inventory.append(chest.tool)
def go_kart():
# Set a global variable to indicate that the player is in a go kart
global go_kart
go_kart = True
# Increase the player’s speed and size
player_speed = 15
player_rect.inflate_ip(50, 50)
# Load the image for the go kart
go_kart = pygame.image.load(‘go_kart.png’)
# Draw the go kart over the player
screen.blit(go_kart, player_rect)
# Check if the player collides with an enemy or a barrier
if pygame.sprite.spritecollideany(player, enemies) or pygame.sprite.spritecollideany(player, barriers):
# If the player collides with an enemy or a barrier, run over it and destroy it
pygame.sprite.spritecollide(player, enemies, True)
pygame.sprite.spritecollide(player, barriers, True)
def freeze_ray():
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the angle between the mouse and the player
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, BLUE, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the line intersects with an enemy or a platform
if pygame.sprite.spritecollideany(line, enemies) or pygame.sprite.spritecollideany(line, platforms):
# If the line intersects with an enemy or a platform, freeze it
pygame.sprite.spritecollide(line, enemies, False, freeze)
pygame.sprite.spritecollide(line, platforms, False, freeze)
def freeze(sprite):
# Change the sprite’s image to a frozen version
sprite.image = pygame.image.load(sprite.name + ‘_frozen.png’)
# Set the sprite’s frozen attribute to True
sprite.frozen = True
def tsunami_maker():
# Set a global variable to indicate that the player has used the tsunami maker
global tsunami
tsunami = True
# Load the image for the wave
wave = pygame.image.load(‘wave.png’)
# Create a rect for the wave
wave_rect = wave.get_rect()
# Set the wave’s initial position at the left edge of the screen
wave_rect.left = 0
# Set the wave’s speed
wave_speed = 10
# Draw the wave on the screen
screen.blit(wave, wave_rect)
# Move the wave to the right
wave_rect.x += wave_speed
# Check if the wave collides with an enemy or a gap
if pygame.sprite.spritecollideany(wave, enemies) or pygame.sprite.spritecollideany(wave, gaps):
# If the wave collides with an enemy or a gap, wash it away
pygame.sprite.spritecollide(wave, enemies, True)
pygame.sprite.spritecollide(wave, gaps, True, fill)
def fill(sprite):
# Change the sprite’s image to a water version
sprite.image = pygame.image.load(sprite.name + ‘_water.png’)
# Set the sprite’s filled attribute to True
sprite.filled = True
def laser_beam():
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the angle between the mouse and the player
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, YELLOW, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the line intersects with an enemy or a barrier
if pygame.sprite.spritecollideany(line, enemies) or pygame.sprite.spritecollideany(line, barriers):
# If the line intersects with an enemy or a barrier, destroy it
pygame.sprite.spritecollide(line, enemies, True)
pygame.sprite.spritecollide(line, barriers, True)
def speed_pill():
# Set a global variable to indicate that the player has used the speed pill
global speed
speed = True
# Set a timer to make the player normal again after 10 seconds
pygame.time.set_timer(pygame.USEREVENT + 1, 10000)
# Increase the player’s speed
player_speed = 10
def revival_kit():
# Set a global variable to indicate that the player has a revival kit
global revival
revival = True
# Check if the player’s health is zero
if player_health == 0:
# If the player’s health is zero, revive the player
player_health = 100
# Set the revival variable to False
revival = False
def is_on_floor_or_stairs(player_rect):
“”“
Check if the player is standing on a floor or stairs cell.
Returns True if standing on floor or stairs, False otherwise.
“””
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Check if the player is on the initial floor rows
if FLOOR_START_ROW <= player_rect.bottom // cell_height <= FLOOR_END_ROW:
for x in range(player_rect.left // cell_width, (player_rect.right + cell_width - 1) // cell_width):
if 0 <= x < GRID_WIDTH:
return True
return False
def draw_doors():
# Define the door’s color
DOOR_COLOR = (139, 69, 19) # Saddle brown color
# Calculate the cell size based on the screen dimensions
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Draw door 1
door1_start_row = GRID_HEIGHT - 10
door1_end_row = GRID_HEIGHT - 13
door1_start_col = 10
door1_end_col = 11
for row in range(door1_start_row, door1_end_row - 1, -1):
for col in range(door1_start_col, door1_end_col + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, DOOR_COLOR, rect)
# Draw door 2
door2_start_row = GRID_HEIGHT - 3
door2_end_row = GRID_HEIGHT - 4
door2_start_col = 16
door2_end_col = 17
for row in range(door2_start_row, door2_end_row - 1, -1):
for col in range(door2_start_col, door2_end_col + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, DOOR_COLOR, rect)
def draw_floor():
# Define the floor’s color
FLOOR_COLOR = (128, 64, 0) # Brown color
STAIRS_COLOR = (128, 128, 128) # Gray color
# Calculate the cell size based on the screen dimensions
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Draw the floor cells
for col in range(GRID_WIDTH):
for row in range(FLOOR_START_ROW, FLOOR_END_ROW + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, FLOOR_COLOR, rect)
enemies = pygame.sprite.Group()
barriers = pygame.sprite.Group()
platforms = pygame.sprite.Group()
doors = pygame.sprite.Group()
chests = pygame.sprite.Group()
gaps = pygame.sprite.Group()
tools = pygame.sprite.Group()
# Create some sprites and groups for the player
player_sprite = pygame.sprite.Sprite()
player_sprite.image = player_image
player_sprite.rect = player_sprite.image.get_rect()
player_sprite.rect.center = (100, 300)
# Create sprite groups
enemies = pygame.sprite.Group()
tools = pygame.sprite.Group() # Assuming tools are also Sprites
# Gravity constant
GRAVITY = 0.5
# Player properties
player_x = 100
player_y = 300
player_speed = 5
player_jump_vel = 10
player_vert_vel = 0 # Initial vertical velocity
player_health = 100
inventory = []
# Main game loop control
running = True
clock = pygame.time.Clock()
show_intro()
# Initialize player jumping state
player_is_jumping = False
while running:
# 1. Handle events
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE and not player_is_jumping:
# Start jumping
player_is_jumping = True
player_vert_vel = -player_jump_vel
# 2. Update game state
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT]:
player_sprite.rect.x -= player_speed
if keys[pygame.K_RIGHT]:
player_sprite.rect.x += player_speed
if keys[pygame.K_UP]:
player_sprite.rect.y -= player_speed
if keys[pygame.K_DOWN]:
player_sprite.rect.y += player_speed
# Update player’s vertical velocity and position if jumping
if player_is_jumping:
player_vert_vel += GRAVITY
player_sprite.rect.y += player_vert_vel
# Check if the player has landed on floor or stairs
if is_on_floor_or_stairs(player_sprite.rect):
player_is_jumping = False
player_vert_vel = 0
else:
# Apply gravity only if not on floor or stairs
if not is_on_floor_or_stairs(player_sprite.rect):
player_vert_vel += GRAVITY
player_sprite.rect.y += player_vert_vel
# Reset vertical velocity if on floor or stairs
if is_on_floor_or_stairs(player_sprite.rect):
player_vert_vel = 0
# Prevent the player from moving off screen
player_sprite.rect.clamp_ip(screen.get_rect())
# 3. Draw everything
screen.blit(background, (0, 0))
draw_floor()
draw_doors()
tools.draw(screen)
enemies.draw(screen)
screen.blit(player_sprite.image, player_sprite.rect) # Draw player
# After drawing everything, update/flip the display
pygame.display.flip()
# 4. Cap the frame rate
clock.tick(60) first lets assign the 3 randomly selected tools they got at start of game to buttons v,b,n. show relevant parts i need to change or add or update..
|
67d5fbb238b2b0c8f9129b1cb44b3cfc
|
{
"intermediate": 0.43946021795272827,
"beginner": 0.3746280372142792,
"expert": 0.18591171503067017
}
|
44,393
|
import pygame
import random
import math
# Initialize pygame and create a screen object
pygame.init()
screen = pygame.display.set_mode((1000, 800))
# Define grid size
GRID_WIDTH = 21
GRID_HEIGHT = 17
# Define initial floor position
FLOOR_START_ROW = GRID_HEIGHT - 2
FLOOR_END_ROW = GRID_HEIGHT - 1
pygame.display.set_caption(‘100% no luck’)
# Load the images for the background, the player, and the boss
# Ensure that these images are present in your project directory
try:
background = pygame.image.load(‘level_1_background.jpeg’)
player_image = pygame.image.load(‘player1_back.png’)
invisibility_cloak_image = pygame.image.load(‘invisibility_cloak.png’)
grappling_hook_image = pygame.image.load(‘grappling_hook.png’)
katana_image = pygame.image.load(‘katana.png’)
freezing_ray_image = pygame.image.load(‘freezing_ray.png’)
speed_pill_image = pygame.image.load(‘speed_pill.jpeg’)
bouncy_shoes_image = pygame.image.load(‘bouncy_shoes.png’)
key_image = pygame.image.load(‘key.png’)
tsunami_maker_image = pygame.image.load(‘tsunami_maker.png’)
laser_beam_image = pygame.image.load(‘laser_beam.png’)
go_kart_image = pygame.image.load(‘go_kart.jpeg’)
revival_kit_image = pygame.image.load(‘revival_kit.jpeg’)
except pygame.error as e:
print(“Cannot load images:”, e)
raise SystemExit
# Define the colors for the text
WHITE = (255, 255, 255)
# Define the font for the text
font = pygame.font.SysFont(‘Arial’, 32)
# Define the text for the intro and the tools
intro_text = “Welcome to 100% no luck, a game where you have to use smart logic and some luck to beat the dungeon. You will spawn with 3 tools out of a possible 15 tools randomized. Each tool has a different effect and can help you or hinder you depending on the situation. You have to think carefully about how to use your tools and when to use them. The dungeon has many obstacles and enemies that you have to overcome. The goal is to reach the end of the dungeon and defeat the boss. Good luck!”
tools_text = [“Invisibility cloak: Makes you invisible for 10 seconds. Useful for sneaking past enemies or traps.”,
“Grappling hook: Allows you to swing across gaps or pull objects towards you.”,
“Katana: A sharp sword that can cut through anything. Useful for fighting enemies or breaking barriers.”,
“Freeze ray: A device that can freeze anything in its path. Useful for stopping enemies or creating platforms.”,
“Bouncy shoes: Shoes that make you jump higher and farther. Useful for reaching high places or avoiding obstacles.”,
“Key: A key that can unlock any door or chest. Useful for accessing hidden areas or treasures.”,
“Go kart: A vehicle that can move fast and run over anything. Useful for escaping enemies or crossing large distances.”,
“Tsunami maker: A device that can create a huge wave of water. Useful for washing away enemies or filling gaps.”,
“Laser beam: A device that can shoot a powerful laser. Useful for destroying enemies or barriers.”,
“Speed pill: A pill that can make you move faster for 10 seconds. Useful for dodging enemies or traps.”,
“Revival kit: A kit that can revive you once if you die. Useful for surviving fatal situations.”]
def show_intro():
intro_text = “Welcome to 100% no luck, a game where you have to use smart logic and some luck to beat the dungeon. You will spawn with 3 tools out of a possible 15 tools randomized. Each tool has a different effect and can help you or hinder you depending on the situation. You have to think carefully about how to use your tools and when to use them. The dungeon has many obstacles and enemies that you have to overcome. The goal is to reach the end of the dungeon and defeat the boss. Good luck!”
# Wrap the intro text
intro_lines = []
max_width = 950 # Adjust as needed
words = intro_text.split()
current_line = words[0]
for word in words[1:]:
if font.size(current_line + ’ ’ + word)[0] < max_width:
current_line += ’ ’ + word
else:
intro_lines.append(current_line)
current_line = word
intro_lines.append(current_line)
current_line = 0
intro_complete = False
start_time = pygame.time.get_ticks()
while not intro_complete:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
screen.fill((0, 0, 0))
intro_surface = font.render(intro_lines[current_line], True, WHITE)
intro_rect = intro_surface.get_rect(center=(screen.get_width() // 2, screen.get_height() // 2))
screen.blit(intro_surface, intro_rect)
if pygame.time.get_ticks() - start_time > 2980:
current_line += 1
start_time = pygame.time.get_ticks()
if current_line == len(intro_lines):
intro_complete = True
pygame.display.flip()
pygame.time.Clock().tick(60)
screen.fill((0, 0, 0))
pygame.display.flip()
tools_title_surface = font.render(“Selected Tools:”, True, WHITE)
tools_title_rect = tools_title_surface.get_rect(center=(screen.get_width() // 2, 100))
screen.blit(tools_title_surface, tools_title_rect)
pygame.display.flip()
pygame.time.delay(1000)
selected_tools = random.sample(tools_text, 3)
# Wrap the tool descriptions
wrapped_tools = []
for tool_desc in selected_tools:
tool_lines = []
current_line = tool_desc.split()[0]
for word in tool_desc.split()[1:]:
if font.size(current_line + ’ ’ + word)[0] < max_width:
current_line += ’ ’ + word
else:
tool_lines.append(current_line)
current_line = word
tool_lines.append(current_line)
wrapped_tools.append(tool_lines)
selected_tools_surface = [font.render(line, True, WHITE) for tool_lines in wrapped_tools for line in tool_lines]
for i, tool_surface in enumerate(selected_tools_surface):
tool_rect = tool_surface.get_rect(center=(screen.get_width() // 2, 200 + i * 50))
screen.blit(tool_surface, tool_rect)
pygame.display.flip()
start_time = pygame.time.get_ticks()
while pygame.time.get_ticks() - start_time < 2000:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
screen.fill((0, 0, 0))
pygame.display.flip()
# Define the logic for each tool as a function
def invisibility_cloak():
# Set a global variable to indicate that the player is invisible
global invisible
invisible = True
# Set a timer to make the player visible again after 10 seconds
pygame.time.set_timer(pygame.USEREVENT, 10000)
def grappling_hook():
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the distance and the angle between the mouse and the player
distance = ((mouse_x - player_x) ** 2 + (mouse_y - player_y) ** 2) ** 0.5
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, BLACK, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the mouse is over a gap or an object
if mouse_x > 600 and mouse_x < 700 and mouse_y > 300 and mouse_y < 400:
# If the mouse is over a gap, move the player towards the mouse
player_rect.centerx += math.cos(angle) * 10
player_rect.centery += math.sin(angle) * 10
elif mouse_x > 700 and mouse_x < 800 and mouse_y > 200 and mouse_y < 300:
# If the mouse is over an object, move the object towards the player
object_rect.centerx -= math.cos(angle) * 10
object_rect.centery -= math.sin(angle) * 10
def katana():
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the angle between the mouse and the player
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, RED, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the line intersects with an enemy or a barrier
if pygame.sprite.spritecollideany(line, enemies) or pygame.sprite.spritecollideany(line, barriers):
# If the line intersects with an enemy or a barrier, destroy it
pygame.sprite.spritecollide(line, enemies, True)
pygame.sprite.spritecollide(line, barriers, True)
def bouncy_shoes():
# Set a global variable to indicate that the player has bouncy shoes
global bouncy
bouncy = True
# Increase the player’s jump velocity
player_jump_vel = 20
def key():
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the distance between the mouse and the player
distance = ((mouse_x - player_x) ** 2 + (mouse_y - player_y) ** 2) ** 0.5
# Check if the mouse is over a door or a chest
if pygame.sprite.spritecollideany(mouse, doors) or pygame.sprite.spritecollideany(mouse, chests):
# If the mouse is over a door or a chest, unlock it and open it
pygame.sprite.spritecollide(mouse, doors, True)
pygame.sprite.spritecollide(mouse, chests, True)
# If the chest contains a tool, add it to the player’s inventory
if chest.tool:
inventory.append(chest.tool)
def go_kart():
# Set a global variable to indicate that the player is in a go kart
global go_kart
go_kart = True
# Increase the player’s speed and size
player_speed = 15
player_rect.inflate_ip(50, 50)
# Load the image for the go kart
go_kart = pygame.image.load(‘go_kart.png’)
# Draw the go kart over the player
screen.blit(go_kart, player_rect)
# Check if the player collides with an enemy or a barrier
if pygame.sprite.spritecollideany(player, enemies) or pygame.sprite.spritecollideany(player, barriers):
# If the player collides with an enemy or a barrier, run over it and destroy it
pygame.sprite.spritecollide(player, enemies, True)
pygame.sprite.spritecollide(player, barriers, True)
def freeze_ray():
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the angle between the mouse and the player
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, BLUE, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the line intersects with an enemy or a platform
if pygame.sprite.spritecollideany(line, enemies) or pygame.sprite.spritecollideany(line, platforms):
# If the line intersects with an enemy or a platform, freeze it
pygame.sprite.spritecollide(line, enemies, False, freeze)
pygame.sprite.spritecollide(line, platforms, False, freeze)
def freeze(sprite):
# Change the sprite’s image to a frozen version
sprite.image = pygame.image.load(sprite.name + ‘_frozen.png’)
# Set the sprite’s frozen attribute to True
sprite.frozen = True
def tsunami_maker():
# Set a global variable to indicate that the player has used the tsunami maker
global tsunami
tsunami = True
# Load the image for the wave
wave = pygame.image.load(‘wave.png’)
# Create a rect for the wave
wave_rect = wave.get_rect()
# Set the wave’s initial position at the left edge of the screen
wave_rect.left = 0
# Set the wave’s speed
wave_speed = 10
# Draw the wave on the screen
screen.blit(wave, wave_rect)
# Move the wave to the right
wave_rect.x += wave_speed
# Check if the wave collides with an enemy or a gap
if pygame.sprite.spritecollideany(wave, enemies) or pygame.sprite.spritecollideany(wave, gaps):
# If the wave collides with an enemy or a gap, wash it away
pygame.sprite.spritecollide(wave, enemies, True)
pygame.sprite.spritecollide(wave, gaps, True, fill)
def fill(sprite):
# Change the sprite’s image to a water version
sprite.image = pygame.image.load(sprite.name + ‘_water.png’)
# Set the sprite’s filled attribute to True
sprite.filled = True
def laser_beam():
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the angle between the mouse and the player
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, YELLOW, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the line intersects with an enemy or a barrier
if pygame.sprite.spritecollideany(line, enemies) or pygame.sprite.spritecollideany(line, barriers):
# If the line intersects with an enemy or a barrier, destroy it
pygame.sprite.spritecollide(line, enemies, True)
pygame.sprite.spritecollide(line, barriers, True)
def speed_pill():
# Set a global variable to indicate that the player has used the speed pill
global speed
speed = True
# Set a timer to make the player normal again after 10 seconds
pygame.time.set_timer(pygame.USEREVENT + 1, 10000)
# Increase the player’s speed
player_speed = 10
def revival_kit():
# Set a global variable to indicate that the player has a revival kit
global revival
revival = True
# Check if the player’s health is zero
if player_health == 0:
# If the player’s health is zero, revive the player
player_health = 100
# Set the revival variable to False
revival = False
def is_on_floor_or_stairs(player_rect):
“”“
Check if the player is standing on a floor or stairs cell.
Returns True if standing on floor or stairs, False otherwise.
“””
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Check if the player is on the initial floor rows
if FLOOR_START_ROW <= player_rect.bottom // cell_height <= FLOOR_END_ROW:
for x in range(player_rect.left // cell_width, (player_rect.right + cell_width - 1) // cell_width):
if 0 <= x < GRID_WIDTH:
return True
return False
def draw_doors():
# Define the door’s color
DOOR_COLOR = (139, 69, 19) # Saddle brown color
# Calculate the cell size based on the screen dimensions
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Draw door 1
door1_start_row = GRID_HEIGHT - 10
door1_end_row = GRID_HEIGHT - 13
door1_start_col = 10
door1_end_col = 11
for row in range(door1_start_row, door1_end_row - 1, -1):
for col in range(door1_start_col, door1_end_col + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, DOOR_COLOR, rect)
# Draw door 2
door2_start_row = GRID_HEIGHT - 3
door2_end_row = GRID_HEIGHT - 4
door2_start_col = 16
door2_end_col = 17
for row in range(door2_start_row, door2_end_row - 1, -1):
for col in range(door2_start_col, door2_end_col + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, DOOR_COLOR, rect)
def draw_floor():
# Define the floor’s color
FLOOR_COLOR = (128, 64, 0) # Brown color
STAIRS_COLOR = (128, 128, 128) # Gray color
# Calculate the cell size based on the screen dimensions
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Draw the floor cells
for col in range(GRID_WIDTH):
for row in range(FLOOR_START_ROW, FLOOR_END_ROW + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, FLOOR_COLOR, rect)
enemies = pygame.sprite.Group()
barriers = pygame.sprite.Group()
platforms = pygame.sprite.Group()
doors = pygame.sprite.Group()
chests = pygame.sprite.Group()
gaps = pygame.sprite.Group()
tools = pygame.sprite.Group()
# Create some sprites and groups for the player
player_sprite = pygame.sprite.Sprite()
player_sprite.image = player_image
player_sprite.rect = player_sprite.image.get_rect()
player_sprite.rect.center = (100, 300)
# Create sprite groups
enemies = pygame.sprite.Group()
tools = pygame.sprite.Group() # Assuming tools are also Sprites
# Gravity constant
GRAVITY = 0.5
# Player properties
player_x = 100
player_y = 300
player_speed = 5
player_jump_vel = 10
player_vert_vel = 0 # Initial vertical velocity
player_health = 100
inventory = []
# Main game loop control
running = True
clock = pygame.time.Clock()
show_intro()
# Initialize player jumping state
player_is_jumping = False
while running:
# 1. Handle events
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE and not player_is_jumping:
# Start jumping
player_is_jumping = True
player_vert_vel = -player_jump_vel
# 2. Update game state
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT]:
player_sprite.rect.x -= player_speed
if keys[pygame.K_RIGHT]:
player_sprite.rect.x += player_speed
if keys[pygame.K_UP]:
player_sprite.rect.y -= player_speed
if keys[pygame.K_DOWN]:
player_sprite.rect.y += player_speed
# Update player’s vertical velocity and position if jumping
if player_is_jumping:
player_vert_vel += GRAVITY
player_sprite.rect.y += player_vert_vel
# Check if the player has landed on floor or stairs
if is_on_floor_or_stairs(player_sprite.rect):
player_is_jumping = False
player_vert_vel = 0
else:
# Apply gravity only if not on floor or stairs
if not is_on_floor_or_stairs(player_sprite.rect):
player_vert_vel += GRAVITY
player_sprite.rect.y += player_vert_vel
# Reset vertical velocity if on floor or stairs
if is_on_floor_or_stairs(player_sprite.rect):
player_vert_vel = 0
# Prevent the player from moving off screen
player_sprite.rect.clamp_ip(screen.get_rect())
# 3. Draw everything
screen.blit(background, (0, 0))
draw_floor()
draw_doors()
tools.draw(screen)
enemies.draw(screen)
screen.blit(player_sprite.image, player_sprite.rect) # Draw player
# After drawing everything, update/flip the display
pygame.display.flip()
# 4. Cap the frame rate
clock.tick(60) first lets assign the 3 randomly selected tools they got at start of game to buttons v,b,n. show relevant parts of code i need to change or add or update.
|
fc95ecf7707ebe3e982d380f551fcb89
|
{
"intermediate": 0.43946021795272827,
"beginner": 0.3746280372142792,
"expert": 0.18591171503067017
}
|
44,394
|
I made an optimizer by fusing two optimizer implementations: 1. SM3 and 2. Adalite.
Code for adalite is as follows:
import torch
import math
from dataclasses import dataclass, field
from typing import List, Optional
from collections import defaultdict
# Somewhat based on https://gist.github.com/albanD/18c240bd2e09f9d93f5c4a0c9ccda39e and LOMO
@dataclass
class OverlapOptimizer:
model: torch.nn.Module
lr: Optional[float] = None
decay: Optional[float] = 0.0
_acc_grads: Optional[List] = field(default_factory=lambda: [])
def init(self):
for p in self.model.parameters():
if p.requires_grad:
self.prepare(p)
self.hook(p)
def step(self, loss, lr):
pass
def hook(self, p):
pass
@dataclass
class OverlapSGD(OverlapOptimizer):
sign: bool = False
def prepare(self, p):
return
def step(self, loss, lr):
self.lr = lr
loss.backward()
def hook(self, p):
ag = p.view_as(p).grad_fn.next_functions[0][0]
p._acc_grads = [ag]
@torch.no_grad()
def gf(*_):
if self.sign:
p.add_(p.grad.sign(), alpha=-self.lr)
else:
p.add_(p.grad, alpha=-self.lr)
p.grad = None
ag.register_hook(gf)
@dataclass
class Adalite(OverlapOptimizer):
eps: float = 1e-5
Lambda: float = 0.01 # Akin to weight-decay
beta_decay: float = 0.8
centralize: bool = True
use_rms: bool = True
momentum: bool = False
momentum_beta: float = 0.9
_t: int = 0
def step(self, loss, lr=None):
self._t += 1
self.lr = lr
loss.backward()
def prepare(self, p):
if len(p.shape) == 2:
p._c = torch.zeros(p.shape[1], device=p.device, dtype=p.dtype)
else:
p._v = torch.zeros_like(p)
if self.momentum:
p._m = torch.zeros_like(p)
def hook(self, p):
ag = p.view_as(p).grad_fn.next_functions[0][0]
p._acc_grads = [ag]
@torch.no_grad()
def gf(*_):
alpha = self.lr
g = p.grad
if self.centralize and sum(g.shape) > 1:
g.sub_(g.mean(dim=tuple(range(1, len(g.shape))), keepdim=True))
beta_t = 1.0 - math.pow(self._t, -self.beta_decay)
u = g.square()
if len(p.shape) == 2:
u.mul_(1-beta_t).add_(p._c.unsqueeze(0).broadcast_to(g.shape), alpha=beta_t)
u.add_(self.eps)
p._c = u.mean(dim=0)
else:
u.mul_(1-beta_t).add_(p._v, alpha=beta_t)
u.add_(self.eps)
p._v = u
m = u.rsqrt() * g
if self.use_rms:
m.div_(max(1.0, m.square().mean().sqrt()))
p_norm = p.norm()
g_norm = g.norm()
if p_norm != 0 and g_norm != 0:
m.mul_(p_norm / g_norm)
m.add_(p - p/p_norm, alpha=self.Lambda)
if self.momentum:
p._m.mul_(self.momentum_beta).add_(m, alpha=1-self.momentum_beta)
m = p._m
p.add_(m, alpha=-alpha)
p.grad = None
ag.register_hook(gf)
After i fused techniques from both adalite and SM3 optimizer. Here is my code for fusedbun optimizer which uses techniwues from both optimizers
import torch
from torch.optim.optimizer import Optimizer
import math
class Fusedbun(Optimizer):
def __init__(self, params, lr=1e-3, eps=1e-8, beta_decay=0.8, Lambda=0.01, momentum_beta=0.9, centralize=True, use_rms=True):
"""
Args:
params (iterable): An iterable of parameters.
lr (float, optional): The learning rate (default: 1e-3).
eps (float, optional): A small value for numerical stability (default: 1e-8).
beta_decay (float, optional): A parameter controlling the rate of decay for the moving average of squared gradients (default: 0.8).
Lambda (float, optional): default: 0.01
momentum_beta (float, optional): Coefficient for the moving average of gradients (momentum) (default: 0.9).
centralize (bool, optional): Boolean indicating whether to centralize gradients to have zero mean (default: True).
use_rms (bool, optional): Boolean indicating whether to use RMSprop-like denominator normalization (default: True).
"""
defaults = dict(lr=lr, eps=eps, beta_decay=beta_decay, Lambda=Lambda, momentum_beta=momentum_beta, centralize=centralize, use_rms=use_rms)
super(Fusedbun, self).__init__(params, defaults)
@torch.no_grad()
def step(self, closure=None):
"""
Args:
closure (callable, optional): A closure that reevaluates the model and returns the loss.
Returns:
loss (Tensor, optional): The loss tensor, if the closure is provided.
"""
loss = None
if closure is not None:
# compute the loss if a closure is provided
loss = closure()
for group in self.param_groups:
lr = group['lr']
eps = group['eps']
beta_decay = group['beta_decay']
Lambda = group['Lambda']
momentum_beta = group['momentum_beta']
centralize = group['centralize']
use_rms = group['use_rms']
for p in group['params']:
if p.grad is None:
continue
grad = p.grad.data
if centralize and len(p.shape) > 1:
# centralize gradients for non-scalar parameters (from adalite)
grad = grad.sub(grad.mean(dim=tuple(range(1, len(grad.shape))), keepdim=True))
state = self.state[p]
if len(state) == 0:
state['step'] = 0
state['exp_avg_sq'] = torch.zeros_like(p, memory_format=torch.preserve_format)
if momentum_beta > 0:
state['momentum_buffer'] = torch.zeros_like(p, memory_format=torch.preserve_format)
exp_avg_sq = state['exp_avg_sq']
state['step'] += 1
if momentum_beta > 0:
momentum_buffer = state['momentum_buffer']
momentum_buffer.mul_(momentum_beta).add_(grad)
grad = momentum_buffer
#sparse update mechanism
if p.dim() > 1:
mask = grad.abs() > eps
grad = grad * mask
exp_avg_sq = torch.where(mask, exp_avg_sq*beta_decay + (1-beta_decay)*grad.pow(2), exp_avg_sq)
else:
exp_avg_sq.mul_(beta_decay).addcmul_(grad, grad, value=1-beta_decay)
denom = exp_avg_sq.sqrt().add_(eps)
grad_normalized = grad / denom if use_rms else grad
if Lambda != 0:
p.data.mul_(1 - lr * Lambda)
p.data.add_(grad_normalized, alpha=-lr)
return loss
Now, implement, hessian approximation matrix technique into my fusedbun optimizer.
Keep comments and explain what is happening with the code.
|
4a28e550f0d24daaef743fca8020f4c7
|
{
"intermediate": 0.2869257628917694,
"beginner": 0.4863451421260834,
"expert": 0.22672908008098602
}
|
44,395
|
import pygame
import random
import math
# Initialize pygame and create a screen object
pygame.init()
screen = pygame.display.set_mode((1000, 800))
# Define grid size
GRID_WIDTH = 21
GRID_HEIGHT = 17
# Define initial floor position
FLOOR_START_ROW = GRID_HEIGHT - 2
FLOOR_END_ROW = GRID_HEIGHT - 1
pygame.display.set_caption(‘100% no luck’)
# Load the images for the background, the player, and the boss
# Ensure that these images are present in your project directory
try:
background = pygame.image.load(‘level_1_background.jpeg’)
player_image = pygame.image.load(‘player1_back.png’)
invisibility_cloak_image = pygame.image.load(‘invisibility_cloak.png’)
grappling_hook_image = pygame.image.load(‘grappling_hook.png’)
katana_image = pygame.image.load(‘katana.png’)
freezing_ray_image = pygame.image.load(‘freezing_ray.png’)
speed_pill_image = pygame.image.load(‘speed_pill.jpeg’)
bouncy_shoes_image = pygame.image.load(‘bouncy_shoes.png’)
key_image = pygame.image.load(‘key.png’)
tsunami_maker_image = pygame.image.load(‘tsunami_maker.png’)
laser_beam_image = pygame.image.load(‘laser_beam.png’)
go_kart_image = pygame.image.load(‘go_kart.jpeg’)
revival_kit_image = pygame.image.load(‘revival_kit.jpeg’)
except pygame.error as e:
print(“Cannot load images:”, e)
raise SystemExit
# Define the colors for the text
WHITE = (255, 255, 255)
# Define the font for the text
font = pygame.font.SysFont(‘Arial’, 32)
# Define the text for the intro and the tools
intro_text = “Welcome to 100% no luck, a game where you have to use smart logic and some luck to beat the dungeon. You will spawn with 3 tools out of a possible 15 tools randomized. Each tool has a different effect and can help you or hinder you depending on the situation. You have to think carefully about how to use your tools and when to use them. The dungeon has many obstacles and enemies that you have to overcome. The goal is to reach the end of the dungeon and defeat the boss. Good luck!”
tools_text = [“Invisibility cloak: Makes you invisible for 10 seconds. Useful for sneaking past enemies or traps.”,
“Grappling hook: Allows you to swing across gaps or pull objects towards you.”,
“Katana: A sharp sword that can cut through anything. Useful for fighting enemies or breaking barriers.”,
“Freeze ray: A device that can freeze anything in its path. Useful for stopping enemies or creating platforms.”,
“Bouncy shoes: Shoes that make you jump higher and farther. Useful for reaching high places or avoiding obstacles.”,
“Key: A key that can unlock any door or chest. Useful for accessing hidden areas or treasures.”,
“Go kart: A vehicle that can move fast and run over anything. Useful for escaping enemies or crossing large distances.”,
“Tsunami maker: A device that can create a huge wave of water. Useful for washing away enemies or filling gaps.”,
“Laser beam: A device that can shoot a powerful laser. Useful for destroying enemies or barriers.”,
“Speed pill: A pill that can make you move faster for 10 seconds. Useful for dodging enemies or traps.”,
“Revival kit: A kit that can revive you once if you die. Useful for surviving fatal situations.”]
def show_intro():
intro_text = “Welcome to 100% no luck, a game where you have to use smart logic and some luck to beat the dungeon. You will spawn with 3 tools out of a possible 15 tools randomized. Each tool has a different effect and can help you or hinder you depending on the situation. You have to think carefully about how to use your tools and when to use them. The dungeon has many obstacles and enemies that you have to overcome. The goal is to reach the end of the dungeon and defeat the boss. Good luck!”
# Wrap the intro text
intro_lines = []
max_width = 950 # Adjust as needed
words = intro_text.split()
current_line = words[0]
for word in words[1:]:
if font.size(current_line + ’ ’ + word)[0] < max_width:
current_line += ’ ’ + word
else:
intro_lines.append(current_line)
current_line = word
intro_lines.append(current_line)
current_line = 0
intro_complete = False
start_time = pygame.time.get_ticks()
while not intro_complete:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
screen.fill((0, 0, 0))
intro_surface = font.render(intro_lines[current_line], True, WHITE)
intro_rect = intro_surface.get_rect(center=(screen.get_width() // 2, screen.get_height() // 2))
screen.blit(intro_surface, intro_rect)
if pygame.time.get_ticks() - start_time > 2980:
current_line += 1
start_time = pygame.time.get_ticks()
if current_line == len(intro_lines):
intro_complete = True
pygame.display.flip()
pygame.time.Clock().tick(60)
screen.fill((0, 0, 0))
pygame.display.flip()
tools_title_surface = font.render(“Selected Tools:”, True, WHITE)
tools_title_rect = tools_title_surface.get_rect(center=(screen.get_width() // 2, 100))
screen.blit(tools_title_surface, tools_title_rect)
pygame.display.flip()
pygame.time.delay(1000)
selected_tools = random.sample(tools_text, 3)
# Wrap the tool descriptions
wrapped_tools = []
for tool_desc in selected_tools:
tool_lines = []
current_line = tool_desc.split()[0]
for word in tool_desc.split()[1:]:
if font.size(current_line + ’ ’ + word)[0] < max_width:
current_line += ’ ’ + word
else:
tool_lines.append(current_line)
current_line = word
tool_lines.append(current_line)
wrapped_tools.append(tool_lines)
selected_tools_surface = [font.render(line, True, WHITE) for tool_lines in wrapped_tools for line in tool_lines]
for i, tool_surface in enumerate(selected_tools_surface):
tool_rect = tool_surface.get_rect(center=(screen.get_width() // 2, 200 + i * 50))
screen.blit(tool_surface, tool_rect)
pygame.display.flip()
start_time = pygame.time.get_ticks()
while pygame.time.get_ticks() - start_time < 2000:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
screen.fill((0, 0, 0))
pygame.display.flip()
# Define the logic for each tool as a function
def invisibility_cloak():
# Set a global variable to indicate that the player is invisible
global invisible
invisible = True
# Set a timer to make the player visible again after 10 seconds
pygame.time.set_timer(pygame.USEREVENT, 10000)
def grappling_hook():
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the distance and the angle between the mouse and the player
distance = ((mouse_x - player_x) ** 2 + (mouse_y - player_y) ** 2) ** 0.5
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, BLACK, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the mouse is over a gap or an object
if mouse_x > 600 and mouse_x < 700 and mouse_y > 300 and mouse_y < 400:
# If the mouse is over a gap, move the player towards the mouse
player_rect.centerx += math.cos(angle) * 10
player_rect.centery += math.sin(angle) * 10
elif mouse_x > 700 and mouse_x < 800 and mouse_y > 200 and mouse_y < 300:
# If the mouse is over an object, move the object towards the player
object_rect.centerx -= math.cos(angle) * 10
object_rect.centery -= math.sin(angle) * 10
def katana():
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the angle between the mouse and the player
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, RED, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the line intersects with an enemy or a barrier
if pygame.sprite.spritecollideany(line, enemies) or pygame.sprite.spritecollideany(line, barriers):
# If the line intersects with an enemy or a barrier, destroy it
pygame.sprite.spritecollide(line, enemies, True)
pygame.sprite.spritecollide(line, barriers, True)
def bouncy_shoes():
# Set a global variable to indicate that the player has bouncy shoes
global bouncy
bouncy = True
# Increase the player’s jump velocity
player_jump_vel = 20
def key():
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the distance between the mouse and the player
distance = ((mouse_x - player_x) ** 2 + (mouse_y - player_y) ** 2) ** 0.5
# Check if the mouse is over a door or a chest
if pygame.sprite.spritecollideany(mouse, doors) or pygame.sprite.spritecollideany(mouse, chests):
# If the mouse is over a door or a chest, unlock it and open it
pygame.sprite.spritecollide(mouse, doors, True)
pygame.sprite.spritecollide(mouse, chests, True)
# If the chest contains a tool, add it to the player’s inventory
if chest.tool:
inventory.append(chest.tool)
def go_kart():
# Set a global variable to indicate that the player is in a go kart
global go_kart
go_kart = True
# Increase the player’s speed and size
player_speed = 15
player_rect.inflate_ip(50, 50)
# Load the image for the go kart
go_kart = pygame.image.load(‘go_kart.png’)
# Draw the go kart over the player
screen.blit(go_kart, player_rect)
# Check if the player collides with an enemy or a barrier
if pygame.sprite.spritecollideany(player, enemies) or pygame.sprite.spritecollideany(player, barriers):
# If the player collides with an enemy or a barrier, run over it and destroy it
pygame.sprite.spritecollide(player, enemies, True)
pygame.sprite.spritecollide(player, barriers, True)
def freeze_ray():
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the angle between the mouse and the player
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, BLUE, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the line intersects with an enemy or a platform
if pygame.sprite.spritecollideany(line, enemies) or pygame.sprite.spritecollideany(line, platforms):
# If the line intersects with an enemy or a platform, freeze it
pygame.sprite.spritecollide(line, enemies, False, freeze)
pygame.sprite.spritecollide(line, platforms, False, freeze)
def freeze(sprite):
# Change the sprite’s image to a frozen version
sprite.image = pygame.image.load(sprite.name + ‘_frozen.png’)
# Set the sprite’s frozen attribute to True
sprite.frozen = True
def tsunami_maker():
# Set a global variable to indicate that the player has used the tsunami maker
global tsunami
tsunami = True
# Load the image for the wave
wave = pygame.image.load(‘wave.png’)
# Create a rect for the wave
wave_rect = wave.get_rect()
# Set the wave’s initial position at the left edge of the screen
wave_rect.left = 0
# Set the wave’s speed
wave_speed = 10
# Draw the wave on the screen
screen.blit(wave, wave_rect)
# Move the wave to the right
wave_rect.x += wave_speed
# Check if the wave collides with an enemy or a gap
if pygame.sprite.spritecollideany(wave, enemies) or pygame.sprite.spritecollideany(wave, gaps):
# If the wave collides with an enemy or a gap, wash it away
pygame.sprite.spritecollide(wave, enemies, True)
pygame.sprite.spritecollide(wave, gaps, True, fill)
def fill(sprite):
# Change the sprite’s image to a water version
sprite.image = pygame.image.load(sprite.name + ‘_water.png’)
# Set the sprite’s filled attribute to True
sprite.filled = True
def laser_beam():
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the angle between the mouse and the player
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, YELLOW, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the line intersects with an enemy or a barrier
if pygame.sprite.spritecollideany(line, enemies) or pygame.sprite.spritecollideany(line, barriers):
# If the line intersects with an enemy or a barrier, destroy it
pygame.sprite.spritecollide(line, enemies, True)
pygame.sprite.spritecollide(line, barriers, True)
def speed_pill():
# Set a global variable to indicate that the player has used the speed pill
global speed
speed = True
# Set a timer to make the player normal again after 10 seconds
pygame.time.set_timer(pygame.USEREVENT + 1, 10000)
# Increase the player’s speed
player_speed = 10
def revival_kit():
# Set a global variable to indicate that the player has a revival kit
global revival
revival = True
# Check if the player’s health is zero
if player_health == 0:
# If the player’s health is zero, revive the player
player_health = 100
# Set the revival variable to False
revival = False
def is_on_floor_or_stairs(player_rect):
“”“
Check if the player is standing on a floor or stairs cell.
Returns True if standing on floor or stairs, False otherwise.
“””
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Check if the player is on the initial floor rows
if FLOOR_START_ROW <= player_rect.bottom // cell_height <= FLOOR_END_ROW:
for x in range(player_rect.left // cell_width, (player_rect.right + cell_width - 1) // cell_width):
if 0 <= x < GRID_WIDTH:
return True
return False
def draw_doors():
# Define the door’s color
DOOR_COLOR = (139, 69, 19) # Saddle brown color
# Calculate the cell size based on the screen dimensions
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Draw door 1
door1_start_row = GRID_HEIGHT - 10
door1_end_row = GRID_HEIGHT - 13
door1_start_col = 10
door1_end_col = 11
for row in range(door1_start_row, door1_end_row - 1, -1):
for col in range(door1_start_col, door1_end_col + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, DOOR_COLOR, rect)
# Draw door 2
door2_start_row = GRID_HEIGHT - 3
door2_end_row = GRID_HEIGHT - 4
door2_start_col = 16
door2_end_col = 17
for row in range(door2_start_row, door2_end_row - 1, -1):
for col in range(door2_start_col, door2_end_col + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, DOOR_COLOR, rect)
def draw_floor():
# Define the floor’s color
FLOOR_COLOR = (128, 64, 0) # Brown color
STAIRS_COLOR = (128, 128, 128) # Gray color
# Calculate the cell size based on the screen dimensions
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Draw the floor cells
for col in range(GRID_WIDTH):
for row in range(FLOOR_START_ROW, FLOOR_END_ROW + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, FLOOR_COLOR, rect)
enemies = pygame.sprite.Group()
barriers = pygame.sprite.Group()
platforms = pygame.sprite.Group()
doors = pygame.sprite.Group()
chests = pygame.sprite.Group()
gaps = pygame.sprite.Group()
tools = pygame.sprite.Group()
# Create some sprites and groups for the player
player_sprite = pygame.sprite.Sprite()
player_sprite.image = player_image
player_sprite.rect = player_sprite.image.get_rect()
player_sprite.rect.center = (100, 300)
# Create sprite groups
enemies = pygame.sprite.Group()
tools = pygame.sprite.Group() # Assuming tools are also Sprites
# Gravity constant
GRAVITY = 0.5
# Player properties
player_x = 100
player_y = 300
player_speed = 5
player_jump_vel = 10
player_vert_vel = 0 # Initial vertical velocity
player_health = 100
inventory = []
# Main game loop control
running = True
clock = pygame.time.Clock()
show_intro()
# Initialize player jumping state
player_is_jumping = False
while running:
# 1. Handle events
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE and not player_is_jumping:
# Start jumping
player_is_jumping = True
player_vert_vel = -player_jump_vel
# 2. Update game state
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT]:
player_sprite.rect.x -= player_speed
if keys[pygame.K_RIGHT]:
player_sprite.rect.x += player_speed
if keys[pygame.K_UP]:
player_sprite.rect.y -= player_speed
if keys[pygame.K_DOWN]:
player_sprite.rect.y += player_speed
# Update player’s vertical velocity and position if jumping
if player_is_jumping:
player_vert_vel += GRAVITY
player_sprite.rect.y += player_vert_vel
# Check if the player has landed on floor or stairs
if is_on_floor_or_stairs(player_sprite.rect):
player_is_jumping = False
player_vert_vel = 0
else:
# Apply gravity only if not on floor or stairs
if not is_on_floor_or_stairs(player_sprite.rect):
player_vert_vel += GRAVITY
player_sprite.rect.y += player_vert_vel
# Reset vertical velocity if on floor or stairs
if is_on_floor_or_stairs(player_sprite.rect):
player_vert_vel = 0
# Prevent the player from moving off screen
player_sprite.rect.clamp_ip(screen.get_rect())
# 3. Draw everything
screen.blit(background, (0, 0))
draw_floor()
draw_doors()
tools.draw(screen)
enemies.draw(screen)
screen.blit(player_sprite.image, player_sprite.rect) # Draw player
# After drawing everything, update/flip the display
pygame.display.flip()
# 4. Cap the frame rate
clock.tick(60) simplify and shorten code
|
a9441f1f911d857333b784729cfb4263
|
{
"intermediate": 0.43946021795272827,
"beginner": 0.3746280372142792,
"expert": 0.18591171503067017
}
|
44,396
|
how to call a function with some argument using html5.run() in lua script ? (defold)
|
cfe27ac72e9563410f3e56d29e9b8f59
|
{
"intermediate": 0.33194610476493835,
"beginner": 0.5306065082550049,
"expert": 0.13744740188121796
}
|
44,397
|
Hi
|
ff179e1cbe90ad6a566198ba0d070f44
|
{
"intermediate": 0.33010533452033997,
"beginner": 0.26984941959381104,
"expert": 0.400045245885849
}
|
44,398
|
아래의 코드에서 임지영이라는 이름이 들어간 링크를 눌리는 스크립트를 작성하고 싶습니다.
<body marginwidth="0" marginheight="0">
<iframe id="player" src="/embed-w3ysp3dfawzf.html" frameborder="0" __idm_id__="81921"></iframe>
<div class="fullscreen"></div>
<span class="panel_toggle toggleable open">
<svg viewBox="0 0 24 24" style="height: 3rem;">
<path fill="currentColor" d="M5,13L9,17L7.6,18.42L1.18,12L7.6,5.58L9,7L5,11H21V13H5M21,6V8H11V6H21M21,16V18H11V16H21Z"></path>
</svg>
</span>
<div class="panel toggleable open">
<span class="episode is-active" data-url="/embed-w3ysp3dfawzf.html">
임지영 - 1 <span class="duration">00:00:31</span>
</span>
<span class="episode is-active" data-url="/embed-7ytja0ho0umo.html">
임지영 - video 2019-11-30 23-31-42 <span class="duration">00:00:17</span>
</span>
<span class="episode is-active" data-url="/embed-vyuesibdo56f.html">
임지영 - video 2019-11-30 23-31-53 <span class="duration">00:00:26</span>
</span>
<span class="episode is-active" data-url="/embed-gtx15gxlmva8.html">
임지영 - video 2019-11-30 23-32-02 <span class="duration">00:00:27</span>
</span>
</div>
<!-- Javascript -->
<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.4.1/jquery.min.js"></script>
<script>
/* global \$*/
var player = {
pinged: false,
init: function() {
\$('.episode').click(function() {
var \$this = \$(this);
\$('.episode').removeClass('is-active');
\$this.addClass('is-active');
player.play(\$this.attr('data-url'));
});
\$('.panel_toggle').click(function() {
\$('.toggleable').toggleClass('open');
if(!player.pinged) {
//\$.post('xxx');
player.pinged = true;
}
});
\$('.fullscreen').click(function() {
var \$this = \$(this), f;
if(\$this.hasClass('is-active')) {
f = document.exitFullscreen || document.webkitExitFullscreen || document.mozCancelFullScreen || document.msExitFullscreen;
f.call(document);
} else {
f = document.body.requestFullScreen || document.body.webkitRequestFullScreen || document.body.mozRequestFullScreen || document.body.msRequestFullscreen;
f.call(document.body);
}
\$this.toggleClass('is-active');
});
},
play: function(url) {
\$('#player').attr('src', url);
}
};
player.init();
</script>
</body>
|
7bb394f757849bd09acff67d4b0f08cb
|
{
"intermediate": 0.2496069371700287,
"beginner": 0.594478189945221,
"expert": 0.15591490268707275
}
|
44,399
|
아래의 코드에서 임지영이라는 이름이 들어간 링크를 눌리는 스크립트를 작성하고 싶습니다. "\$"를 출력할 땐 앞에 "\"를 꼭 포함해서 출력해주세요.
<body marginwidth="0" marginheight="0">
<iframe id="player" src="/embed-w3ysp3dfawzf.html" frameborder="0" __idm_id__="81921"></iframe>
<div class="fullscreen"></div>
<span class="panel_toggle toggleable open">
<svg viewBox="0 0 24 24" style="height: 3rem;">
<path fill="currentColor" d="M5,13L9,17L7.6,18.42L1.18,12L7.6,5.58L9,7L5,11H21V13H5M21,6V8H11V6H21M21,16V18H11V16H21Z"></path>
</svg>
</span>
<div class="panel toggleable open">
<span class="episode is-active" data-url="/embed-w3ysp3dfawzf.html">
임지영 - 1 <span class="duration">00:00:31</span>
</span>
<span class="episode is-active" data-url="/embed-7ytja0ho0umo.html">
임지영 - video 2019-11-30 23-31-42 <span class="duration">00:00:17</span>
</span>
<span class="episode is-active" data-url="/embed-vyuesibdo56f.html">
임지영 - video 2019-11-30 23-31-53 <span class="duration">00:00:26</span>
</span>
<span class="episode is-active" data-url="/embed-gtx15gxlmva8.html">
임지영 - video 2019-11-30 23-32-02 <span class="duration">00:00:27</span>
</span>
</div>
<!-- Javascript -->
<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.4.1/jquery.min.js"></script>
<script>
/* global \$*/
var player = {
pinged: false,
init: function() {
\$('.episode').click(function() {
var \$this = \$(this);
\$('.episode').removeClass('is-active');
\$this.addClass('is-active');
player.play(\$this.attr('data-url'));
});
\$('.panel_toggle').click(function() {
\$('.toggleable').toggleClass('open');
if(!player.pinged) {
//\$.post('xxx');
player.pinged = true;
}
});
\$('.fullscreen').click(function() {
var \$this = \$(this), f;
if(\$this.hasClass('is-active')) {
f = document.exitFullscreen || document.webkitExitFullscreen || document.mozCancelFullScreen || document.msExitFullscreen;
f.call(document);
} else {
f = document.body.requestFullScreen || document.body.webkitRequestFullScreen || document.body.mozRequestFullScreen || document.body.msRequestFullscreen;
f.call(document.body);
}
\$this.toggleClass('is-active');
});
},
play: function(url) {
\$('#player').attr('src', url);
}
};
player.init();
</script>
</body>
|
531b657d0f45f688c9b39688a94c4397
|
{
"intermediate": 0.2644110321998596,
"beginner": 0.5481227040290833,
"expert": 0.18746626377105713
}
|
44,400
|
import pygame
import random
import math
# Initialize pygame and create a screen object
pygame.init()
screen = pygame.display.set_mode((1000, 800))
# Define colors
BLACK = (0, 0, 0)
RED = (255, 0, 0)
# Define grid size
GRID_WIDTH = 21
GRID_HEIGHT = 17
# Define initial floor position
FLOOR_START_ROW = GRID_HEIGHT - 2
FLOOR_END_ROW = GRID_HEIGHT - 1
pygame.display.set_caption('100% no luck')
# Load the images for the background, the player, and the boss
# Ensure that these images are present in your project directory
try:
background = pygame.image.load('level_1_background.jpeg')
player_image = pygame.image.load('player1_back.png')
invisibility_cloak_image = pygame.image.load('invisibility_cloak.png')
grappling_hook_image = pygame.image.load('grappling_hook.png')
katana_image = pygame.image.load('katana.png')
freezing_ray_image = pygame.image.load('freezing_ray.png')
speed_pill_image = pygame.image.load('speed_pill.jpeg')
bouncy_shoes_image = pygame.image.load('bouncy_shoes.png')
key_image = pygame.image.load('key.png')
tsunami_maker_image = pygame.image.load('tsunami_maker.png')
laser_beam_image = pygame.image.load('laser_beam.png')
go_kart_image = pygame.image.load('go_kart.jpeg')
revival_kit_image = pygame.image.load('revival_kit.jpeg')
except pygame.error as e:
print("Cannot load images:", e)
raise SystemExit
# Define the colors for the text
WHITE = (255, 255, 255)
# Define the font for the text
font = pygame.font.SysFont('Arial', 32)
# Define the text for the intro and the tools
intro_text = "Welcome to 100% no luck, a game where you have to use smart logic and some luck to beat the dungeon. You will spawn with 3 tools out of a possible 15 tools randomized. Each tool has a different effect and can help you or hinder you depending on the situation. You have to think carefully about how to use your tools and when to use them. The dungeon has many obstacles and enemies that you have to overcome. The goal is to reach the end of the dungeon and defeat the boss. Good luck!"
tools_text = ["Invisibility cloak: Makes you invisible for 10 seconds. Useful for sneaking past enemies or traps.",
"Grappling hook: Allows you to swing across gaps or pull objects towards you.",
"Katana: A sharp sword that can cut through anything. Useful for fighting enemies or breaking barriers.",
"Freeze ray: A device that can freeze anything in its path. Useful for stopping enemies or creating platforms.",
"Bouncy shoes: Shoes that make you jump higher and farther. Useful for reaching high places or avoiding obstacles.",
"Key: A key that can unlock any door or chest. Useful for accessing hidden areas or treasures.",
"Go kart: A vehicle that can move fast and run over anything. Useful for escaping enemies or crossing large distances.",
"Tsunami maker: A device that can create a huge wave of water. Useful for washing away enemies or filling gaps.",
"Laser beam: A device that can shoot a powerful laser. Useful for destroying enemies or barriers.",
"Speed pill: A pill that can make you move faster for 10 seconds. Useful for dodging enemies or traps.",
"Revival kit: A kit that can revive you once if you die. Useful for surviving fatal situations."]
# Assign buttons to the selected tools
button_assignments = ['v', 'b', 'n']
def show_intro():
intro_text = "Welcome to 100% no luck, a game where you have to use smart logic and some luck to beat the dungeon. You will spawn with 3 tools out of a possible 15 tools randomized. Each tool has a different effect and can help you or hinder you depending on the situation. You have to think carefully about how to use your tools and when to use them. The dungeon has many obstacles and enemies that you have to overcome. The goal is to reach the end of the dungeon and defeat the boss. Good luck!"
# Wrap the intro text
intro_lines = []
max_width = 950 # Adjust as needed
words = intro_text.split()
current_line = words[0]
for word in words[1:]:
if font.size(current_line + ' ' + word)[0] < max_width:
current_line += ' ' + word
else:
intro_lines.append(current_line)
current_line = word
intro_lines.append(current_line)
current_line = 0
intro_complete = False
start_time = pygame.time.get_ticks()
while not intro_complete:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
screen.fill((0, 0, 0))
intro_surface = font.render(intro_lines[current_line], True, WHITE)
intro_rect = intro_surface.get_rect(center=(screen.get_width() // 2, screen.get_height() // 2))
screen.blit(intro_surface, intro_rect)
if pygame.time.get_ticks() - start_time > 2980:
current_line += 1
start_time = pygame.time.get_ticks()
if current_line == len(intro_lines):
intro_complete = True
pygame.display.flip()
pygame.time.Clock().tick(60)
screen.fill((0, 0, 0))
pygame.display.flip()
tools_title_surface = font.render("Selected Tools:", True, WHITE)
tools_title_rect = tools_title_surface.get_rect(center=(screen.get_width() // 2, 100))
screen.blit(tools_title_surface, tools_title_rect)
pygame.display.flip()
pygame.time.delay(1000)
selected_tools = random.sample(tools_text, 3)
# Assign buttons to the selected tools
button_assignments = ['v', 'b', 'n']
# Wrap the tool descriptions and display them with their assigned buttons
wrapped_tools = []
for i, tool_desc in enumerate(selected_tools):
tool_lines = []
current_line = f"{button_assignments[i]}: {tool_desc.split()[0]}"
for word in tool_desc.split()[1:]:
if font.size(current_line + ' ' + word)[0] < max_width:
current_line += ' ' + word
else:
tool_lines.append(current_line)
current_line = word
tool_lines.append(current_line)
wrapped_tools.append(tool_lines)
selected_tools_surface = [font.render(line, True, WHITE) for tool_lines in wrapped_tools for line in tool_lines]
for i, tool_surface in enumerate(selected_tools_surface):
tool_rect = tool_surface.get_rect(center=(screen.get_width() // 2, 200 + i * 50))
screen.blit(tool_surface, tool_rect)
pygame.display.flip()
start_time = pygame.time.get_ticks()
while pygame.time.get_ticks() - start_time < 2000:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
screen.fill((0, 0, 0))
pygame.display.flip()
# Define the logic for each tool as a function
def invisibility_cloak(player_rect):
# Set a global variable to indicate that the player is invisible
global invisible
invisible = True
# Set a timer to make the player visible again after 10 seconds
pygame.time.set_timer(pygame.USEREVENT, 10000)
def grappling_hook(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the distance and the angle between the mouse and the player
distance = ((mouse_x - player_x) ** 2 + (mouse_y - player_y) ** 2) ** 0.5
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, BLACK, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the mouse is over a gap or an object
if mouse_x > 600 and mouse_x < 700 and mouse_y > 300 and mouse_y < 400:
# If the mouse is over a gap, move the player towards the mouse
player_rect.centerx += math.cos(angle) * 10
player_rect.centery += math.sin(angle) * 10
elif mouse_x > 700 and mouse_x < 800 and mouse_y > 200 and mouse_y < 300:
# If the mouse is over an object, move the object towards the player
object_rect.centerx -= math.cos(angle) * 10
object_rect.centery -= math.sin(angle) * 10
def katana(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the angle between the mouse and the player
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Create a line surface or rect from the player to the mouse
line_length = math.hypot(mouse_x - player_x, mouse_y - player_y)
line = pygame.Surface((line_length, 5), pygame.SRCALPHA)
line.fill(RED)
line_rect = line.get_rect()
line_rect.center = player_rect.center
line_rect = line_rect.rotate(math.degrees(angle))
# Check if the line intersects with an enemy or a barrier
if pygame.sprite.spritecollideany(line_rect, enemies) or pygame.sprite.spritecollideany(line_rect, barriers):
# If the line intersects with an enemy or a barrier, destroy it
pygame.sprite.spritecollide(line_rect, enemies, True)
pygame.sprite.spritecollide(line_rect, barriers, True)
# Draw the line on the screen
screen.blit(line, line_rect)
def bouncy_shoes(player_rect):
# Set a global variable to indicate that the player has bouncy shoes
global bouncy
bouncy = True
# Increase the player's jump velocity
player_jump_vel = 20
def key(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the distance between the mouse and the player
distance = ((mouse_x - player_x) ** 2 + (mouse_y - player_y) ** 2) ** 0.5
# Check if the mouse is over a door or a chest
if pygame.sprite.spritecollideany(mouse, doors) or pygame.sprite.spritecollideany(mouse, chests):
# If the mouse is over a door or a chest, unlock it and open it
pygame.sprite.spritecollide(mouse, doors, True)
pygame.sprite.spritecollide(mouse, chests, True)
# If the chest contains a tool, add it to the player's inventory
if chest.tool:
inventory.append(chest.tool)
def go_kart(player_rect):
# Set a global variable to indicate that the player is in a go kart
global go_kart
go_kart = True
# Increase the player's speed and size
player_speed = 15
player_rect.inflate_ip(50, 50)
# Load the image for the go kart
go_kart = pygame.image.load('go_kart.png')
# Draw the go kart over the player
screen.blit(go_kart, player_rect)
# Check if the player collides with an enemy or a barrier
if pygame.sprite.spritecollideany(player, enemies) or pygame.sprite.spritecollideany(player, barriers):
# If the player collides with an enemy or a barrier, run over it and destroy it
pygame.sprite.spritecollide(player, enemies, True)
pygame.sprite.spritecollide(player, barriers, True)
def freeze_ray(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the angle between the mouse and the player
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, BLUE, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the line intersects with an enemy or a platform
if pygame.sprite.spritecollideany(line, enemies) or pygame.sprite.spritecollideany(line, platforms):
# If the line intersects with an enemy or a platform, freeze it
pygame.sprite.spritecollide(line, enemies, False, freeze)
pygame.sprite.spritecollide(line, platforms, False, freeze)
def freeze(sprite):
# Change the sprite's image to a frozen version
sprite.image = pygame.image.load(sprite.name + '_frozen.png')
# Set the sprite's frozen attribute to True
sprite.frozen = True
def tsunami_maker(player_rect):
# Set a global variable to indicate that the player has used the tsunami maker
global tsunami
tsunami = True
# Load the image for the wave
wave = pygame.image.load('wave.png')
# Create a rect for the wave
wave_rect = wave.get_rect()
# Set the wave's initial position at the left edge of the screen
wave_rect.left = 0
# Set the wave's speed
wave_speed = 10
# Draw the wave on the screen
screen.blit(wave, wave_rect)
# Move the wave to the right
wave_rect.x += wave_speed
# Check if the wave collides with an enemy or a gap
if pygame.sprite.spritecollideany(wave, enemies) or pygame.sprite.spritecollideany(wave, gaps):
# If the wave collides with an enemy or a gap, wash it away
pygame.sprite.spritecollide(wave, enemies, True)
pygame.sprite.spritecollide(wave, gaps, True, fill)
def fill(sprite):
# Change the sprite's image to a water version
sprite.image = pygame.image.load(sprite.name + '_water.png')
# Set the sprite's filled attribute to True
sprite.filled = True
def laser_beam(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the angle between the mouse and the player
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, YELLOW, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the line intersects with an enemy or a barrier
if pygame.sprite.spritecollideany(line, enemies) or pygame.sprite.spritecollideany(line, barriers):
# If the line intersects with an enemy or a barrier, destroy it
pygame.sprite.spritecollide(line, enemies, True)
pygame.sprite.spritecollide(line, barriers, True)
def speed_pill(player_rect):
# Set a global variable to indicate that the player has used the speed pill
global speed
speed = True
# Set a timer to make the player normal again after 10 seconds
pygame.time.set_timer(pygame.USEREVENT + 1, 10000)
# Increase the player's speed
player_speed = 10
def revival_kit(player_rect):
# Set a global variable to indicate that the player has a revival kit
global revival
revival = True
# Check if the player's health is zero
if player_health == 0:
# If the player's health is zero, revive the player
player_health = 100
# Set the revival variable to False
revival = False
tool_functions = [invisibility_cloak, grappling_hook, katana, freeze_ray, bouncy_shoes, key,
go_kart, tsunami_maker, laser_beam, speed_pill, revival_kit]
def is_on_floor_or_stairs(player_rect):
"""
Check if the player is standing on a floor or stairs cell.
Returns True if standing on floor or stairs, False otherwise.
"""
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Check if the player is on the initial floor rows
if FLOOR_START_ROW <= player_rect.bottom // cell_height <= FLOOR_END_ROW:
for x in range(player_rect.left // cell_width, (player_rect.right + cell_width - 1) // cell_width):
if 0 <= x < GRID_WIDTH:
return True
return False
def draw_doors():
# Define the door's color
DOOR_COLOR = (139, 69, 19) # Saddle brown color
# Calculate the cell size based on the screen dimensions
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Draw door 1
door1_start_row = GRID_HEIGHT - 10
door1_end_row = GRID_HEIGHT - 13
door1_start_col = 10
door1_end_col = 11
for row in range(door1_start_row, door1_end_row - 1, -1):
for col in range(door1_start_col, door1_end_col + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, DOOR_COLOR, rect)
# Draw door 2
door2_start_row = GRID_HEIGHT - 3
door2_end_row = GRID_HEIGHT - 4
door2_start_col = 16
door2_end_col = 17
for row in range(door2_start_row, door2_end_row - 1, -1):
for col in range(door2_start_col, door2_end_col + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, DOOR_COLOR, rect)
def draw_floor():
# Define the floor's color
FLOOR_COLOR = (128, 64, 0) # Brown color
STAIRS_COLOR = (128, 128, 128) # Gray color
# Calculate the cell size based on the screen dimensions
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Draw the floor cells
for col in range(GRID_WIDTH):
for row in range(FLOOR_START_ROW, FLOOR_END_ROW + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, FLOOR_COLOR, rect)
enemies = pygame.sprite.Group()
barriers = pygame.sprite.Group()
platforms = pygame.sprite.Group()
doors = pygame.sprite.Group()
chests = pygame.sprite.Group()
gaps = pygame.sprite.Group()
tools = pygame.sprite.Group()
# Create some sprites and groups for the player
player_sprite = pygame.sprite.Sprite()
player_sprite.image = player_image
player_sprite.rect = player_sprite.image.get_rect()
player_sprite.rect.center = (100, 300)
# Create sprite groups
enemies = pygame.sprite.Group()
tools = pygame.sprite.Group() # Assuming tools are also Sprites
# Gravity constant
GRAVITY = 0.5
# Player properties
player_x = 100
player_y = 300
player_speed = 5
player_jump_vel = 10
player_vert_vel = 0 # Initial vertical velocity
player_health = 100
inventory = []
# Main game loop control
running = True
clock = pygame.time.Clock()
show_intro()
# Initialize player jumping state
player_is_jumping = False
# In the main game loop
while running:
# 1. Handle events
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE and not player_is_jumping:
# Start jumping
player_is_jumping = True
player_vert_vel = -player_jump_vel
elif event.key == pygame.K_v:
# Use the first selected tool
try:
tool_functions[button_assignments.index('v')](player_sprite.rect) # Pass player_sprite.rect
except Exception as e:
print(f"Error calling tool function: {e}")
elif event.key == pygame.K_b:
# Use the second selected tool
try:
tool_functions[button_assignments.index('b')](player_sprite.rect) # Pass player_sprite.rect
except Exception as e:
print(f"Error calling tool function: {e}")
elif event.key == pygame.K_n:
# Use the third selected tool
try:
tool_functions[button_assignments.index('n')](player_sprite.rect) # Pass player_sprite.rect
except Exception as e:
print(f"Error calling tool function: {e}")
# 2. Update game state
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT]:
player_sprite.rect.x -= player_speed
if keys[pygame.K_RIGHT]:
player_sprite.rect.x += player_speed
if keys[pygame.K_UP]:
player_sprite.rect.y -= player_speed
if keys[pygame.K_DOWN]:
player_sprite.rect.y += player_speed
# Update player's vertical velocity and position if jumping
if player_is_jumping:
player_vert_vel += GRAVITY
player_sprite.rect.y += player_vert_vel
# Check if the player has landed on floor or stairs
if is_on_floor_or_stairs(player_sprite.rect):
player_is_jumping = False
player_vert_vel = 0
else:
# Apply gravity only if not on floor or stairs
if not is_on_floor_or_stairs(player_sprite.rect):
player_vert_vel += GRAVITY
player_sprite.rect.y += player_vert_vel
# Reset vertical velocity if on floor or stairs
if is_on_floor_or_stairs(player_sprite.rect):
player_vert_vel = 0
# Prevent the player from moving off screen
player_sprite.rect.clamp_ip(screen.get_rect())
# 3. Draw everything
screen.blit(background, (0, 0))
draw_floor()
draw_doors()
tools.draw(screen)
enemies.draw(screen)
screen.blit(player_sprite.image, player_sprite.rect) # Draw player
# After drawing everything, update/flip the display
pygame.display.flip()
# 4. Cap the frame rate
clock.tick(60)
if __name__ == "__main__":
main() v, b, n not doing anything ingame
|
a47e7124b02e44ca41ea94cda51f74b7
|
{
"intermediate": 0.26791539788246155,
"beginner": 0.3290341794490814,
"expert": 0.40305033326148987
}
|
44,401
|
CREATE: Create a custom screen saver by using the try exept code ive shown,below toolkit and setting x and y-speeds!
Useful Links: Example #1
Be sure to read the technical requirements in the comments!
Saving and Submitting: Run your code often to save it, and Submit to turn in and share your work!
try:
x = 5 / 0
except:
print("Cannot divide by 0")
|
3a5cd14242fffb4c84344fbf681e5e7d
|
{
"intermediate": 0.36289501190185547,
"beginner": 0.3617324233055115,
"expert": 0.27537259459495544
}
|
44,402
|
in the following the canvas does not appear when i click on the button:
import tkinter as tk
from tkinter import font
class TextField(tk.Text):
def init(self, *args, **kwargs):
super().init(*args, **kwargs)
self.font = font.Font(size=24)
self.config(font=self.font)
self.bind("", self.on_resize)
def on_resize(self, event):
# Calculate the new font size based on the window size
new_size = -max(1, int(self.w / self.font.measure(" ")))
self.font.config(size=new_size)
self.config(font=self.font)
class CanvasField(tk.Canvas):
def init(self, *args, **kwargs):
super().init(*args, **kwargs)
class Application(tk.Tk):
def init(self):
super().init()
self.title("Text Field / Canvas")
self.text_field = TextField(self)
self.canvas_field = CanvasField(self)
self.text_field.pack(side="top", fill="both", expand=True)
self.canvas_field.pack(side="top", fill="both", expand=True)
self.text_field.pack_forget()
self.canvas_field.pack(side="top", fill="both", expand=True)
self.text_button = tk.Button(self, text="Text Field", command=self.switch_to_text)
self.canvas_button = tk.Button(self, text="Canvas", command=self.switch_to_canvas)
self.text_button.pack(side="bottom", fill="x")
self.canvas_button.pack(side="bottom", fill="x")
def switch_to_text(self):
self.text_field.pack(side="top", fill="both", expand=True)
self.canvas_field.pack_forget()
self.text_button.config(state="disabled")
self.canvas_button.config(state="normal")
def switch_to_canvas(self):
self.text_field.pack_forget()
self.canvas_field.pack(side="top", fill="both", expand=True)
self.text_button.config(state="normal")
self.canvas_button.config(state="disabled")
if name == "main":
app = Application()
app.mainloop()
|
7f0aea25cea12724d0d9db0b5b2ab20a
|
{
"intermediate": 0.3792969584465027,
"beginner": 0.28278931975364685,
"expert": 0.33791372179985046
}
|
44,403
|
axum cors middleware max permissive
|
6bed33502cbdea19f156f27ada0ceae7
|
{
"intermediate": 0.4735821783542633,
"beginner": 0.23037032783031464,
"expert": 0.29604750871658325
}
|
44,404
|
what does this mean?: ""You can obtain PowerInfer GGUF weights at *.powerinfer.gguf ""
|
1de353e6f12dfab3e50effee62547d0c
|
{
"intermediate": 0.30848896503448486,
"beginner": 0.21339865028858185,
"expert": 0.4781123101711273
}
|
44,405
|
write a c++ variadic template function MyFunc() that can be called as MyFunc({1, "string"}, {2, std::vector<int>()}, ...) with arbitrary number of pairs {int, Type1}, {int, Type2} etc.
The function should output the integer. If second element of the pair is std::string, it should also be sent to output.
|
900399749eea28251f4ad55afb39c755
|
{
"intermediate": 0.31957635283470154,
"beginner": 0.5109508633613586,
"expert": 0.16947287321090698
}
|
44,406
|
In servicenow, i have a 3 choice field named as "State" with choices 'In Use' and 'In Stock', "Declaration State" with choices 'Initiated' and 'Declare', "Declare" with choices 'Select' and 'Yes'. my requirement is when a user select In use then decalaration state should be initiated and declare should be select. and if user select in stock then decalaration state should be None and declare should be None and Vice versa if the user select change the state from in use to in stock then decalaration state should be initiated and declare should be select and if user changes the state from in usIn servicenow, i have a 3 choice field named as “State” with choices ‘In Use’ and ‘In Stock’, “Declaration State” with choices ‘Initiated’ and ‘Declare’, “Declare” with choices ‘Select’ and ‘Yes’. my requirement is when a user select In use then decalaration state should be initiated and declare should be select. and if user select in stock then decalaration state should be None and declare should be None and Vice versa if the user select change the state from in stock to in use then decalaration state should be initiated and declare should be select and if user changes the state from in use to in stock then decalaration state should be None and declare should be None. But after saving the form user will able to change the declare choice as yes then it will work, user manually allow to change the values of declaration state and declare, untill state value not changes. Need business rule for this requirement
|
3f19e85f547fb7ff950474c3254e31ed
|
{
"intermediate": 0.3079555332660675,
"beginner": 0.37019699811935425,
"expert": 0.32184749841690063
}
|
44,407
|
I am having two seperate codes, main code 'RL_GNN_CktEnv.py' and sub code 'NetToGraph.py'
where in 'NetToGraph.py', i made a code for performing the function 'node_features, node_features_tensor, edge_features, edge_embeddings, adjacency_matrix, adjacency_matrix_tensor, degree_matrix = netlist_to_graph(netlist_content, parameter).
the main code is designed for the circuit environment for the reinforcement learning based GNN implementation, i need you to include the function 'netlist_to_graph' which is executing in the sub code 'NetToGraph.py' and executed by the main code 'RL_GNN_CktEnv.py'. I need you to include the function 'netlist_to_graph' appropriately with in the main code, where results 'node_features_tensor, edge_embeddings, adjacency_matrix' from the function are going as input to the RL GNN model.
RL_GNN_CktEnv.py(main code):
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
import torch.distributions
from torch.utils.data import TensorDataset, DataLoader
from Simulator_Env import CircuitSimulator
class CircuitEnvironment:
def __init__(self, server_address, username, password, bounds_low, bounds_high, target_metrics):
self.server_address = server_address
self.username = username
self.password = password
self.bounds_low = bounds_low
self.bounds_high = bounds_high
self.target_metrics = target_metrics
self.previous_transistor_regions = None
self.simulator = None
def connect_to_simulator(self):
self.simulator = CircuitSimulator(self.server_address, self.username, self.password)
self.simulator.connect()
def disconnect_from_simulator(self):
if self.simulator:
self.simulator.close()
self.simulator = None
def normalize_parameters(self, parameters):
return normalized_parameters
def encode_regions(self, transistor_regions):
return encoded_regions
def encode_saturation_condition(self, saturation_condition):
# Encode saturation condition as binary indicator
def normalize_performance_metrics(self, performance_metrics):
return normalized_metrics
def reset(self):
# Initialize parameters within bounds
initial_parameters = np.random.uniform(self.bounds_low, self.bounds_high)
# Run simulation with initial parameters
return state, performance_metrics
def step(self, raw_actions, previous_metrics):
return state, reward, done, previous_metrics
def is_performance_metrics_in_target(self, metrics):
return np.all(metrics >= self.PERFORMANCE_METRICS_TARGET_LOW) and np.all(metrics <= self.PERFORMANCE_METRICS_TARGET_HIGH)
def calculate_reward(self, c_metrics, p_metrics, transistor_regions, previous_transistor_regions):
return reward
def check_done(self, performance_metrics, encoded_saturation_condition):
# Check if all performance metrics are within target range and saturation condition is met
|
0a4c811b1686de47ebb129b1434c7e80
|
{
"intermediate": 0.3104831576347351,
"beginner": 0.4249038100242615,
"expert": 0.2646130323410034
}
|
44,408
|
import pygame
import random
import math
# Initialize pygame and create a screen object
pygame.init()
screen = pygame.display.set_mode((1000, 800))
# Define colors
BLACK = (0, 0, 0)
RED = (255, 0, 0)
# Define grid size
GRID_WIDTH = 21
GRID_HEIGHT = 17
# Define initial floor position
FLOOR_START_ROW = GRID_HEIGHT - 2
FLOOR_END_ROW = GRID_HEIGHT - 1
pygame.display.set_caption('100% no luck')
# Load the images for the background, the player, and the boss
# Ensure that these images are present in your project directory
try:
background = pygame.image.load('level_1_background.jpeg')
player_image = pygame.image.load('player1_back.png')
invisibility_cloak_image = pygame.image.load('invisibility_cloak.png')
grappling_hook_image = pygame.image.load('grappling_hook.png')
katana_image = pygame.image.load('katana.png')
freezing_ray_image = pygame.image.load('freezing_ray.png')
speed_pill_image = pygame.image.load('speed_pill.jpeg')
bouncy_shoes_image = pygame.image.load('bouncy_shoes.png')
key_image = pygame.image.load('key.png')
tsunami_maker_image = pygame.image.load('tsunami_maker.png')
laser_beam_image = pygame.image.load('laser_beam.png')
go_kart_image = pygame.image.load('go_kart.jpeg')
revival_kit_image = pygame.image.load('revival_kit.jpeg')
except pygame.error as e:
print("Cannot load images:", e)
raise SystemExit
# Define the colors for the text
WHITE = (255, 255, 255)
# Define the font for the text
font = pygame.font.SysFont('Arial', 32)
# Define the text for the intro and the tools
intro_text = "Welcome to 100% no luck, a game where you have to use smart logic and some luck to beat the dungeon. You will spawn with 3 tools out of a possible 15 tools randomized. Each tool has a different effect and can help you or hinder you depending on the situation. You have to think carefully about how to use your tools and when to use them. The dungeon has many obstacles and enemies that you have to overcome. The goal is to reach the end of the dungeon and defeat the boss. Good luck!"
tools_text = ["Invisibility cloak: Makes you invisible for 10 seconds. Useful for sneaking past enemies or traps.",
"Grappling hook: Allows you to swing across gaps or pull objects towards you.",
"Katana: A sharp sword that can cut through anything. Useful for fighting enemies or breaking barriers.",
"Freeze ray: A device that can freeze anything in its path. Useful for stopping enemies or creating platforms.",
"Bouncy shoes: Shoes that make you jump higher and farther. Useful for reaching high places or avoiding obstacles.",
"Key: A key that can unlock any door or chest. Useful for accessing hidden areas or treasures.",
"Go kart: A vehicle that can move fast and run over anything. Useful for escaping enemies or crossing large distances.",
"Tsunami maker: A device that can create a huge wave of water. Useful for washing away enemies or filling gaps.",
"Laser beam: A device that can shoot a powerful laser. Useful for destroying enemies or barriers.",
"Speed pill: A pill that can make you move faster for 10 seconds. Useful for dodging enemies or traps.",
"Revival kit: A kit that can revive you once if you die. Useful for surviving fatal situations."]
# Assign buttons to the selected tools
button_assignments = ['v', 'b', 'n']
def show_intro():
intro_text = "Welcome to 100% no luck, a game where you have to use smart logic and some luck to beat the dungeon. You will spawn with 3 tools out of a possible 15 tools randomized. Each tool has a different effect and can help you or hinder you depending on the situation. You have to think carefully about how to use your tools and when to use them. The dungeon has many obstacles and enemies that you have to overcome. The goal is to reach the end of the dungeon and defeat the boss. Good luck!"
# Wrap the intro text
intro_lines = []
max_width = 950 # Adjust as needed
words = intro_text.split()
current_line = words[0]
for word in words[1:]:
if font.size(current_line + ' ' + word)[0] < max_width:
current_line += ' ' + word
else:
intro_lines.append(current_line)
current_line = word
intro_lines.append(current_line)
current_line = 0
intro_complete = False
start_time = pygame.time.get_ticks()
while not intro_complete:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
screen.fill((0, 0, 0))
intro_surface = font.render(intro_lines[current_line], True, WHITE)
intro_rect = intro_surface.get_rect(center=(screen.get_width() // 2, screen.get_height() // 2))
screen.blit(intro_surface, intro_rect)
if pygame.time.get_ticks() - start_time > 2980:
current_line += 1
start_time = pygame.time.get_ticks()
if current_line == len(intro_lines):
intro_complete = True
pygame.display.flip()
pygame.time.Clock().tick(60)
screen.fill((0, 0, 0))
pygame.display.flip()
tools_title_surface = font.render("Selected Tools:", True, WHITE)
tools_title_rect = tools_title_surface.get_rect(center=(screen.get_width() // 2, 100))
screen.blit(tools_title_surface, tools_title_rect)
pygame.display.flip()
pygame.time.delay(1000)
selected_tools = random.sample(tools_text, 3)
# Assign buttons to the selected tools
button_assignments = ['v', 'b', 'n']
button_assigned_functions = [tool_functions[tools_text.index(tool)] for tool in selected_tools]
# Wrap the tool descriptions and display them with their assigned buttons
wrapped_tools = []
for i, tool_desc in enumerate(selected_tools):
tool_lines = []
current_line = f"{button_assignments[i]}: {tool_desc.split()[0]}"
for word in tool_desc.split()[1:]:
if font.size(current_line + ' ' + word)[0] < max_width:
current_line += ' ' + word
else:
tool_lines.append(current_line)
current_line = word
tool_lines.append(current_line)
wrapped_tools.append(tool_lines)
selected_tools_surface = [font.render(line, True, WHITE) for tool_lines in wrapped_tools for line in tool_lines]
for i, tool_surface in enumerate(selected_tools_surface):
tool_rect = tool_surface.get_rect(center=(screen.get_width() // 2, 200 + i * 50))
screen.blit(tool_surface, tool_rect)
pygame.display.flip()
start_time = pygame.time.get_ticks()
while pygame.time.get_ticks() - start_time < 2000:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
screen.fill((0, 0, 0))
pygame.display.flip()
return button_assigned_functions
# Define the logic for each tool as a function
def invisibility_cloak(player_rect):
# Set a global variable to indicate that the player is invisible
global invisible
invisible = True
# Set a timer to make the player visible again after 10 seconds
pygame.time.set_timer(pygame.USEREVENT, 10000)
def grappling_hook(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the distance and the angle between the mouse and the player
distance = ((mouse_x - player_x) ** 2 + (mouse_y - player_y) ** 2) ** 0.5
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, BLACK, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the mouse is over a gap or an object
if mouse_x > 600 and mouse_x < 700 and mouse_y > 300 and mouse_y < 400:
# If the mouse is over a gap, move the player towards the mouse
player_rect.centerx += math.cos(angle) * 10
player_rect.centery += math.sin(angle) * 10
elif mouse_x > 700 and mouse_x < 800 and mouse_y > 200 and mouse_y < 300:
# If the mouse is over an object, move the object towards the player
object_rect.centerx -= math.cos(angle) * 10
object_rect.centery -= math.sin(angle) * 10
def katana(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the angle between the mouse and the player
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Create a line surface or rect from the player to the mouse
line_length = math.hypot(mouse_x - player_x, mouse_y - player_y)
line_surf = pygame.Surface((line_length, 5), pygame.SRCALPHA)
line_surf.fill(RED)
line_rect = line_surf.get_rect()
line_rect.center = player_rect.center
# Rotate the line surface
rotated_line_surf = pygame.transform.rotate(line_surf, math.degrees(angle))
# Create a sprite for the rotated line
line_sprite = pygame.sprite.Sprite()
line_sprite.image = rotated_line_surf
line_sprite.rect = rotated_line_surf.get_rect(center=line_rect.center)
# Check if the line intersects with an enemy or a barrier
collided_enemies = pygame.sprite.spritecollide(line_sprite, enemies, True)
collided_barriers = pygame.sprite.spritecollide(line_sprite, barriers, True)
# Draw the rotated line on the screen
screen.blit(rotated_line_surf, line_sprite.rect)
def bouncy_shoes(player_rect):
# Set a global variable to indicate that the player has bouncy shoes
global bouncy
bouncy = True
# Increase the player's jump velocity
player_jump_vel = 20
def key(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the distance between the mouse and the player
distance = ((mouse_x - player_x) ** 2 + (mouse_y - player_y) ** 2) ** 0.5
# Check if the mouse is over a door or a chest
if pygame.sprite.spritecollideany(mouse, doors) or pygame.sprite.spritecollideany(mouse, chests):
# If the mouse is over a door or a chest, unlock it and open it
pygame.sprite.spritecollide(mouse, doors, True)
pygame.sprite.spritecollide(mouse, chests, True)
# If the chest contains a tool, add it to the player's inventory
if chest.tool:
inventory.append(chest.tool)
def go_kart(player_rect):
# Set a global variable to indicate that the player is in a go kart
global go_kart
go_kart = True
# Increase the player's speed and size
player_speed = 15
player_rect.inflate_ip(50, 50)
# Load the image for the go kart
go_kart = pygame.image.load('go_kart.png')
# Draw the go kart over the player
screen.blit(go_kart, player_rect)
# Check if the player collides with an enemy or a barrier
if pygame.sprite.spritecollideany(player, enemies) or pygame.sprite.spritecollideany(player, barriers):
# If the player collides with an enemy or a barrier, run over it and destroy it
pygame.sprite.spritecollide(player, enemies, True)
pygame.sprite.spritecollide(player, barriers, True)
def freeze_ray(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the angle between the mouse and the player
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, BLUE, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the line intersects with an enemy or a platform
if pygame.sprite.spritecollideany(line, enemies) or pygame.sprite.spritecollideany(line, platforms):
# If the line intersects with an enemy or a platform, freeze it
pygame.sprite.spritecollide(line, enemies, False, freeze)
pygame.sprite.spritecollide(line, platforms, False, freeze)
def freeze(sprite):
# Change the sprite's image to a frozen version
sprite.image = pygame.image.load(sprite.name + '_frozen.png')
# Set the sprite's frozen attribute to True
sprite.frozen = True
def tsunami_maker(player_rect):
# Set a global variable to indicate that the player has used the tsunami maker
global tsunami
tsunami = True
# Load the image for the wave
wave = pygame.image.load('wave.png')
# Create a rect for the wave
wave_rect = wave.get_rect()
# Set the wave's initial position at the left edge of the screen
wave_rect.left = 0
# Set the wave's speed
wave_speed = 10
# Draw the wave on the screen
screen.blit(wave, wave_rect)
# Move the wave to the right
wave_rect.x += wave_speed
# Check if the wave collides with an enemy or a gap
if pygame.sprite.spritecollideany(wave, enemies) or pygame.sprite.spritecollideany(wave, gaps):
# If the wave collides with an enemy or a gap, wash it away
pygame.sprite.spritecollide(wave, enemies, True)
pygame.sprite.spritecollide(wave, gaps, True, fill)
def fill(sprite):
# Change the sprite's image to a water version
sprite.image = pygame.image.load(sprite.name + '_water.png')
# Set the sprite's filled attribute to True
sprite.filled = True
def laser_beam(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the angle between the mouse and the player
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, YELLOW, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the line intersects with an enemy or a barrier
if pygame.sprite.spritecollideany(line, enemies) or pygame.sprite.spritecollideany(line, barriers):
# If the line intersects with an enemy or a barrier, destroy it
pygame.sprite.spritecollide(line, enemies, True)
pygame.sprite.spritecollide(line, barriers, True)
def speed_pill(player_rect):
# Set a global variable to indicate that the player has used the speed pill
global speed
speed = True
# Set a timer to make the player normal again after 10 seconds
pygame.time.set_timer(pygame.USEREVENT + 1, 10000)
# Increase the player's speed
player_speed = 10
def revival_kit(player_rect):
# Set a global variable to indicate that the player has a revival kit
global revival
revival = True
# Check if the player's health is zero
if player_health == 0:
# If the player's health is zero, revive the player
player_health = 100
# Set the revival variable to False
revival = False
tool_functions = [invisibility_cloak, grappling_hook, katana, freeze_ray, bouncy_shoes, key,
go_kart, tsunami_maker, laser_beam, speed_pill, revival_kit]
def is_on_floor_or_stairs(player_rect):
"""
Check if the player is standing on a floor or stairs cell.
Returns True if standing on floor or stairs, False otherwise.
"""
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Check if the player is on the initial floor rows
if FLOOR_START_ROW <= player_rect.bottom // cell_height <= FLOOR_END_ROW:
for x in range(player_rect.left // cell_width, (player_rect.right + cell_width - 1) // cell_width):
if 0 <= x < GRID_WIDTH:
return True
return False
def draw_doors():
# Define the door's color
DOOR_COLOR = (139, 69, 19) # Saddle brown color
# Calculate the cell size based on the screen dimensions
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Draw door 1
door1_start_row = GRID_HEIGHT - 10
door1_end_row = GRID_HEIGHT - 13
door1_start_col = 10
door1_end_col = 11
for row in range(door1_start_row, door1_end_row - 1, -1):
for col in range(door1_start_col, door1_end_col + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, DOOR_COLOR, rect)
# Draw door 2
door2_start_row = GRID_HEIGHT - 3
door2_end_row = GRID_HEIGHT - 4
door2_start_col = 16
door2_end_col = 17
for row in range(door2_start_row, door2_end_row - 1, -1):
for col in range(door2_start_col, door2_end_col + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, DOOR_COLOR, rect)
def draw_floor():
# Define the floor's color
FLOOR_COLOR = (128, 64, 0) # Brown color
STAIRS_COLOR = (128, 128, 128) # Gray color
# Calculate the cell size based on the screen dimensions
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Draw the floor cells
for col in range(GRID_WIDTH):
for row in range(FLOOR_START_ROW, FLOOR_END_ROW + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, FLOOR_COLOR, rect)
enemies = pygame.sprite.Group()
barriers = pygame.sprite.Group()
platforms = pygame.sprite.Group()
doors = pygame.sprite.Group()
chests = pygame.sprite.Group()
gaps = pygame.sprite.Group()
tools = pygame.sprite.Group()
# Create some sprites and groups for the player
player_sprite = pygame.sprite.Sprite()
player_sprite.image = player_image
player_sprite.rect = player_sprite.image.get_rect()
player_sprite.rect.center = (100, 300)
# Create sprite groups
enemies = pygame.sprite.Group()
tools = pygame.sprite.Group() # Assuming tools are also Sprites
# Gravity constant
GRAVITY = 0.5
# Player properties
player_x = 100
player_y = 300
player_speed = 5
player_jump_vel = 10
player_vert_vel = 0 # Initial vertical velocity
player_health = 100
inventory = []
# Main game loop control
running = True
clock = pygame.time.Clock()
# Call show_intro() and get the button_assigned_functions list
button_assigned_functions = show_intro()
# Initialize player jumping state
player_is_jumping = False
# Create a rect for the player sprite
player_rect = player_sprite.rect
# In the main game loop
while running:
# 1. Handle events
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE and not player_is_jumping:
# Start jumping
player_is_jumping = True
player_vert_vel = -player_jump_vel
elif event.key == pygame.K_v:
# Use the first selected tool
try:
tool_functions[button_assignments.index('v')](player_sprite.rect) # Pass player_sprite.rect
except Exception as e:
print(f"Error calling tool function: {e}")
elif event.key == pygame.K_b:
# Use the second selected tool
try:
tool_functions[button_assignments.index('b')](player_sprite.rect) # Pass player_sprite.rect
except Exception as e:
print(f"Error calling tool function: {e}")
elif event.key == pygame.K_n:
# Use the third selected tool
try:
tool_functions[button_assignments.index('n')](player_sprite.rect) # Pass player_sprite.rect
except Exception as e:
print(f"Error calling tool function: {e}")
# 2. Update game state
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT]:
player_sprite.rect.x -= player_speed
if keys[pygame.K_RIGHT]:
player_sprite.rect.x += player_speed
if keys[pygame.K_UP]:
player_sprite.rect.y -= player_speed
if keys[pygame.K_DOWN]:
player_sprite.rect.y += player_speed
# Update player's vertical velocity and position if jumping
if player_is_jumping:
player_vert_vel += GRAVITY
player_sprite.rect.y += player_vert_vel
# Check if the player has landed on floor or stairs
if is_on_floor_or_stairs(player_sprite.rect):
player_is_jumping = False
player_vert_vel = 0
else:
# Apply gravity only if not on floor or stairs
if not is_on_floor_or_stairs(player_sprite.rect):
player_vert_vel += GRAVITY
player_sprite.rect.y += player_vert_vel
# Reset vertical velocity if on floor or stairs
if is_on_floor_or_stairs(player_sprite.rect):
player_vert_vel = 0
# Prevent the player from moving off screen
player_sprite.rect.clamp_ip(screen.get_rect())
# 3. Draw everything
screen.blit(background, (0, 0))
draw_floor()
draw_doors()
tools.draw(screen)
enemies.draw(screen)
screen.blit(player_sprite.image, player_sprite.rect) # Draw player
# After drawing everything, update/flip the display
pygame.display.flip()
# 4. Cap the frame rate
clock.tick(60)
if __name__ == "__main__":
main() ok but why is 3 automatically katana its supposed to be the random 3 the player got at start but if this keeps happening when n is pressed it means n is 3 which is not supposed to be case
|
51a2c9c4f21fd9be71461bd3d7cb2cb4
|
{
"intermediate": 0.26791539788246155,
"beginner": 0.3290341794490814,
"expert": 0.40305033326148987
}
|
44,409
|
import pygame
import random
import math
# Initialize pygame and create a screen object
pygame.init()
screen = pygame.display.set_mode((1000, 800))
# Define colors
BLACK = (0, 0, 0)
RED = (255, 0, 0)
# Define grid size
GRID_WIDTH = 21
GRID_HEIGHT = 17
# Define initial floor position
FLOOR_START_ROW = GRID_HEIGHT - 2
FLOOR_END_ROW = GRID_HEIGHT - 1
pygame.display.set_caption('100% no luck')
# Load the images for the background, the player, and the boss
# Ensure that these images are present in your project directory
try:
background = pygame.image.load('level_1_background.jpeg')
player_image = pygame.image.load('player1_back.png')
invisibility_cloak_image = pygame.image.load('invisibility_cloak.png')
grappling_hook_image = pygame.image.load('grappling_hook.png')
katana_image = pygame.image.load('katana.png')
freezing_ray_image = pygame.image.load('freezing_ray.png')
speed_pill_image = pygame.image.load('speed_pill.jpeg')
bouncy_shoes_image = pygame.image.load('bouncy_shoes.png')
key_image = pygame.image.load('key.png')
tsunami_maker_image = pygame.image.load('tsunami_maker.png')
laser_beam_image = pygame.image.load('laser_beam.png')
go_kart_image = pygame.image.load('go_kart.jpeg')
revival_kit_image = pygame.image.load('revival_kit.jpeg')
except pygame.error as e:
print("Cannot load images:", e)
raise SystemExit
# Define the colors for the text
WHITE = (255, 255, 255)
# Define the font for the text
font = pygame.font.SysFont('Arial', 32)
# Define the text for the intro and the tools
intro_text = "Welcome to 100% no luck, a game where you have to use smart logic and some luck to beat the dungeon. You will spawn with 3 tools out of a possible 15 tools randomized. Each tool has a different effect and can help you or hinder you depending on the situation. You have to think carefully about how to use your tools and when to use them. The dungeon has many obstacles and enemies that you have to overcome. The goal is to reach the end of the dungeon and defeat the boss. Good luck!"
tools_text = ["Invisibility cloak: Makes you invisible for 10 seconds. Useful for sneaking past enemies or traps.",
"Grappling hook: Allows you to swing across gaps or pull objects towards you.",
"Katana: A sharp sword that can cut through anything. Useful for fighting enemies or breaking barriers.",
"Freeze ray: A device that can freeze anything in its path. Useful for stopping enemies or creating platforms.",
"Bouncy shoes: Shoes that make you jump higher and farther. Useful for reaching high places or avoiding obstacles.",
"Key: A key that can unlock any door or chest. Useful for accessing hidden areas or treasures.",
"Go kart: A vehicle that can move fast and run over anything. Useful for escaping enemies or crossing large distances.",
"Tsunami maker: A device that can create a huge wave of water. Useful for washing away enemies or filling gaps.",
"Laser beam: A device that can shoot a powerful laser. Useful for destroying enemies or barriers.",
"Speed pill: A pill that can make you move faster for 10 seconds. Useful for dodging enemies or traps.",
"Revival kit: A kit that can revive you once if you die. Useful for surviving fatal situations."]
def show_intro():
intro_text = "Welcome to 100% no luck, a game where you have to use smart logic and some luck to beat the dungeon. You will spawn with 3 tools out of a possible 15 tools randomized. Each tool has a different effect and can help you or hinder you depending on the situation. You have to think carefully about how to use your tools and when to use them. The dungeon has many obstacles and enemies that you have to overcome. The goal is to reach the end of the dungeon and defeat the boss. Good luck!"
# Wrap the intro text
intro_lines = []
max_width = 950 # Adjust as needed
words = intro_text.split()
current_line = words[0]
for word in words[1:]:
if font.size(current_line + ' ' + word)[0] < max_width:
current_line += ' ' + word
else:
intro_lines.append(current_line)
current_line = word
intro_lines.append(current_line)
current_line = 0
intro_complete = False
start_time = pygame.time.get_ticks()
while not intro_complete:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
screen.fill((0, 0, 0))
intro_surface = font.render(intro_lines[current_line], True, WHITE)
intro_rect = intro_surface.get_rect(center=(screen.get_width() // 2, screen.get_height() // 2))
screen.blit(intro_surface, intro_rect)
if pygame.time.get_ticks() - start_time > 2980:
current_line += 1
start_time = pygame.time.get_ticks()
if current_line == len(intro_lines):
intro_complete = True
pygame.display.flip()
pygame.time.Clock().tick(60)
screen.fill((0, 0, 0))
pygame.display.flip()
tools_title_surface = font.render("Selected Tools:", True, WHITE)
tools_title_rect = tools_title_surface.get_rect(center=(screen.get_width() // 2, 100))
screen.blit(tools_title_surface, tools_title_rect)
pygame.display.flip()
pygame.time.delay(1000)
available_buttons = ['v', 'b', 'n', 'x', 'y', 'z'] # Add more buttons if needed
selected_tools = random.sample(tools_text, 3)
# Assign buttons to the selected tools
button_assignments = available_buttons[:3] # Take the first three buttons
button_assigned_functions = [tool_functions[tools_text.index(tool)] for tool in selected_tools]
# Wrap the tool descriptions and display them with their assigned buttons
wrapped_tools = []
for i, tool_desc in enumerate(selected_tools):
tool_lines = []
current_line = f"{button_assignments[i]}: {tool_desc.split()[0]}"
for word in tool_desc.split()[1:]:
if font.size(current_line + ' ' + word)[0] < max_width:
current_line += ' ' + word
else:
tool_lines.append(current_line)
current_line = word
tool_lines.append(current_line)
wrapped_tools.append(tool_lines)
selected_tools_surface = [font.render(line, True, WHITE) for tool_lines in wrapped_tools for line in tool_lines]
for i, tool_surface in enumerate(selected_tools_surface):
tool_rect = tool_surface.get_rect(center=(screen.get_width() // 2, 200 + i * 50))
screen.blit(tool_surface, tool_rect)
pygame.display.flip()
start_time = pygame.time.get_ticks()
while pygame.time.get_ticks() - start_time < 2000:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
screen.fill((0, 0, 0))
pygame.display.flip()
return button_assignments, button_assigned_functions
# Define the logic for each tool as a function
def invisibility_cloak(player_rect):
# Set a global variable to indicate that the player is invisible
global invisible
invisible = True
# Set a timer to make the player visible again after 10 seconds
pygame.time.set_timer(pygame.USEREVENT, 10000)
def grappling_hook(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the distance and the angle between the mouse and the player
distance = ((mouse_x - player_x) ** 2 + (mouse_y - player_y) ** 2) ** 0.5
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, BLACK, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the mouse is over a gap or an object
if mouse_x > 600 and mouse_x < 700 and mouse_y > 300 and mouse_y < 400:
# If the mouse is over a gap, move the player towards the mouse
player_rect.centerx += math.cos(angle) * 10
player_rect.centery += math.sin(angle) * 10
elif mouse_x > 700 and mouse_x < 800 and mouse_y > 200 and mouse_y < 300:
# If the mouse is over an object, move the object towards the player
object_rect.centerx -= math.cos(angle) * 10
object_rect.centery -= math.sin(angle) * 10
def katana(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the angle between the mouse and the player
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Create a line surface or rect from the player to the mouse
line_length = math.hypot(mouse_x - player_x, mouse_y - player_y)
line_surf = pygame.Surface((line_length, 5), pygame.SRCALPHA)
line_surf.fill(RED)
line_rect = line_surf.get_rect()
line_rect.center = player_rect.center
# Rotate the line surface
rotated_line_surf = pygame.transform.rotate(line_surf, math.degrees(angle))
# Create a sprite for the rotated line
line_sprite = pygame.sprite.Sprite()
line_sprite.image = rotated_line_surf
line_sprite.rect = rotated_line_surf.get_rect(center=line_rect.center)
# Check if the line intersects with an enemy or a barrier
collided_enemies = pygame.sprite.spritecollide(line_sprite, enemies, True)
collided_barriers = pygame.sprite.spritecollide(line_sprite, barriers, True)
# Draw the rotated line on the screen
screen.blit(rotated_line_surf, line_sprite.rect)
def bouncy_shoes(player_rect):
# Set a global variable to indicate that the player has bouncy shoes
global bouncy
bouncy = True
# Increase the player's jump velocity
player_jump_vel = 20
def key(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the distance between the mouse and the player
distance = ((mouse_x - player_x) ** 2 + (mouse_y - player_y) ** 2) ** 0.5
# Check if the mouse is over a door or a chest
if pygame.sprite.spritecollideany(mouse, doors) or pygame.sprite.spritecollideany(mouse, chests):
# If the mouse is over a door or a chest, unlock it and open it
pygame.sprite.spritecollide(mouse, doors, True)
pygame.sprite.spritecollide(mouse, chests, True)
# If the chest contains a tool, add it to the player's inventory
if chest.tool:
inventory.append(chest.tool)
def go_kart(player_rect):
# Set a global variable to indicate that the player is in a go kart
global go_kart
go_kart = True
# Increase the player's speed and size
player_speed = 15
player_rect.inflate_ip(50, 50)
# Load the image for the go kart
go_kart = pygame.image.load('go_kart.png')
# Draw the go kart over the player
screen.blit(go_kart, player_rect)
# Check if the player collides with an enemy or a barrier
if pygame.sprite.spritecollideany(player, enemies) or pygame.sprite.spritecollideany(player, barriers):
# If the player collides with an enemy or a barrier, run over it and destroy it
pygame.sprite.spritecollide(player, enemies, True)
pygame.sprite.spritecollide(player, barriers, True)
def freeze_ray(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the angle between the mouse and the player
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, BLUE, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the line intersects with an enemy or a platform
if pygame.sprite.spritecollideany(line, enemies) or pygame.sprite.spritecollideany(line, platforms):
# If the line intersects with an enemy or a platform, freeze it
pygame.sprite.spritecollide(line, enemies, False, freeze)
pygame.sprite.spritecollide(line, platforms, False, freeze)
def freeze(sprite):
# Change the sprite's image to a frozen version
sprite.image = pygame.image.load(sprite.name + '_frozen.png')
# Set the sprite's frozen attribute to True
sprite.frozen = True
def tsunami_maker(player_rect):
# Set a global variable to indicate that the player has used the tsunami maker
global tsunami
tsunami = True
# Load the image for the wave
wave = pygame.image.load('wave.png')
# Create a rect for the wave
wave_rect = wave.get_rect()
# Set the wave's initial position at the left edge of the screen
wave_rect.left = 0
# Set the wave's speed
wave_speed = 10
# Draw the wave on the screen
screen.blit(wave, wave_rect)
# Move the wave to the right
wave_rect.x += wave_speed
# Check if the wave collides with an enemy or a gap
if pygame.sprite.spritecollideany(wave, enemies) or pygame.sprite.spritecollideany(wave, gaps):
# If the wave collides with an enemy or a gap, wash it away
pygame.sprite.spritecollide(wave, enemies, True)
pygame.sprite.spritecollide(wave, gaps, True, fill)
def fill(sprite):
# Change the sprite's image to a water version
sprite.image = pygame.image.load(sprite.name + '_water.png')
# Set the sprite's filled attribute to True
sprite.filled = True
def laser_beam(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the angle between the mouse and the player
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, YELLOW, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the line intersects with an enemy or a barrier
if pygame.sprite.spritecollideany(line, enemies) or pygame.sprite.spritecollideany(line, barriers):
# If the line intersects with an enemy or a barrier, destroy it
pygame.sprite.spritecollide(line, enemies, True)
pygame.sprite.spritecollide(line, barriers, True)
def speed_pill(player_rect):
# Set a global variable to indicate that the player has used the speed pill
global speed
speed = True
# Set a timer to make the player normal again after 10 seconds
pygame.time.set_timer(pygame.USEREVENT + 1, 10000)
# Increase the player's speed
player_speed = 10
def revival_kit(player_rect):
# Set a global variable to indicate that the player has a revival kit
global revival
revival = True
# Check if the player's health is zero
if player_health == 0:
# If the player's health is zero, revive the player
player_health = 100
# Set the revival variable to False
revival = False
tool_functions = [invisibility_cloak, grappling_hook, katana, freeze_ray, bouncy_shoes, key,
go_kart, tsunami_maker, laser_beam, speed_pill, revival_kit]
def is_on_floor_or_stairs(player_rect):
"""
Check if the player is standing on a floor or stairs cell.
Returns True if standing on floor or stairs, False otherwise.
"""
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Check if the player is on the initial floor rows
if FLOOR_START_ROW <= player_rect.bottom // cell_height <= FLOOR_END_ROW:
for x in range(player_rect.left // cell_width, (player_rect.right + cell_width - 1) // cell_width):
if 0 <= x < GRID_WIDTH:
return True
return False
def draw_doors():
# Define the door's color
DOOR_COLOR = (139, 69, 19) # Saddle brown color
# Calculate the cell size based on the screen dimensions
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Draw door 1
door1_start_row = GRID_HEIGHT - 10
door1_end_row = GRID_HEIGHT - 13
door1_start_col = 10
door1_end_col = 11
for row in range(door1_start_row, door1_end_row - 1, -1):
for col in range(door1_start_col, door1_end_col + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, DOOR_COLOR, rect)
# Draw door 2
door2_start_row = GRID_HEIGHT - 3
door2_end_row = GRID_HEIGHT - 4
door2_start_col = 16
door2_end_col = 17
for row in range(door2_start_row, door2_end_row - 1, -1):
for col in range(door2_start_col, door2_end_col + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, DOOR_COLOR, rect)
def draw_floor():
# Define the floor's color
FLOOR_COLOR = (128, 64, 0) # Brown color
STAIRS_COLOR = (128, 128, 128) # Gray color
# Calculate the cell size based on the screen dimensions
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Draw the floor cells
for col in range(GRID_WIDTH):
for row in range(FLOOR_START_ROW, FLOOR_END_ROW + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, FLOOR_COLOR, rect)
enemies = pygame.sprite.Group()
barriers = pygame.sprite.Group()
platforms = pygame.sprite.Group()
doors = pygame.sprite.Group()
chests = pygame.sprite.Group()
gaps = pygame.sprite.Group()
tools = pygame.sprite.Group()
# Create some sprites and groups for the player
player_sprite = pygame.sprite.Sprite()
player_sprite.image = player_image
player_sprite.rect = player_sprite.image.get_rect()
player_sprite.rect.center = (100, 300)
# Create sprite groups
enemies = pygame.sprite.Group()
tools = pygame.sprite.Group() # Assuming tools are also Sprites
# Gravity constant
GRAVITY = 0.5
# Player properties
player_x = 100
player_y = 300
player_speed = 5
player_jump_vel = 10
player_vert_vel = 0 # Initial vertical velocity
player_health = 100
inventory = []
# Main game loop control
running = True
clock = pygame.time.Clock()
# Call show_intro() and get the button_assigned_functions list
button_assignments, button_assigned_functions = show_intro()
# Initialize player jumping state
player_is_jumping = False
# Create a rect for the player sprite
player_rect = player_sprite.rect
# In the main game loop
while running:
# 1. Handle events
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE and not player_is_jumping:
# Start jumping
player_is_jumping = True
player_vert_vel = -player_jump_vel
elif event.key == ord(button_assignments[0].upper()): # Use the first selected tool
try:
button_assigned_functions[0](player_sprite.rect) # Pass player_sprite.rect
except Exception as e:
print(f"Error calling tool function: {e}")
elif event.key == ord(button_assignments[1].upper()): # Use the second selected tool
try:
button_assigned_functions[1](player_sprite.rect) # Pass player_sprite.rect
except Exception as e:
print(f"Error calling tool function: {e}")
elif event.key == ord(button_assignments[2].upper()): # Use the third selected tool
try:
button_assigned_functions[2](player_sprite.rect) # Pass player_sprite.rect
except Exception as e:
print(f"Error calling tool function: {e}")
# 2. Update game state
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT]:
player_sprite.rect.x -= player_speed
if keys[pygame.K_RIGHT]:
player_sprite.rect.x += player_speed
if keys[pygame.K_UP]:
player_sprite.rect.y -= player_speed
if keys[pygame.K_DOWN]:
player_sprite.rect.y += player_speed
# Update player's vertical velocity and position if jumping
if player_is_jumping:
player_vert_vel += GRAVITY
player_sprite.rect.y += player_vert_vel
# Check if the player has landed on floor or stairs
if is_on_floor_or_stairs(player_sprite.rect):
player_is_jumping = False
player_vert_vel = 0
else:
# Apply gravity only if not on floor or stairs
if not is_on_floor_or_stairs(player_sprite.rect):
player_vert_vel += GRAVITY
player_sprite.rect.y += player_vert_vel
# Reset vertical velocity if on floor or stairs
if is_on_floor_or_stairs(player_sprite.rect):
player_vert_vel = 0
# Prevent the player from moving off screen
player_sprite.rect.clamp_ip(screen.get_rect())
# 3. Draw everything
screen.blit(background, (0, 0))
draw_floor()
draw_doors()
tools.draw(screen)
enemies.draw(screen)
screen.blit(player_sprite.image, player_sprite.rect) # Draw player
# Check if the player is invisible
if invisible:
# Draw the invisibility cloak image over the player
screen.blit(invisibility_cloak_image, player_sprite.rect)
# After drawing everything, update/flip the display
pygame.display.flip()
# 4. Cap the frame rate
clock.tick(60)
if __name__ == "__main__":
main() how to stop game from closing because it shows error message but i cant see it cause game closes
|
e3f9e0cc93d8122c0b7a17918481b477
|
{
"intermediate": 0.24399136006832123,
"beginner": 0.35880452394485474,
"expert": 0.39720413088798523
}
|
44,410
|
how to make wsl2 use all CPU and RAM
|
01fdb021d418ee23b4d9c4177e3825a4
|
{
"intermediate": 0.31247785687446594,
"beginner": 0.16850538551807404,
"expert": 0.5190168023109436
}
|
44,411
|
format(os.getpid())
|
96ac9d2002d0bdc22988d3590d6dee17
|
{
"intermediate": 0.31714391708374023,
"beginner": 0.3769230246543884,
"expert": 0.30593305826187134
}
|
44,412
|
React Route page constantly reloads. How can I prevent it?
|
33aa389cf0d968190459ababaca0d1d4
|
{
"intermediate": 0.45205849409103394,
"beginner": 0.30705833435058594,
"expert": 0.24088314175605774
}
|
44,413
|
Hi, in VSCode I create a repository with GIthub extension, than I transfer to ownership to my company account. However, I am not able to synchronize the project with the transferred repository. Do you know how to fix such issue?
|
ea1e6cc7f6242fb3202bd6b902afe3e3
|
{
"intermediate": 0.46668553352355957,
"beginner": 0.2346849888563156,
"expert": 0.2986295223236084
}
|
44,414
|
Can I run a bldc motor using an arduino
|
ff5975f78e353f62d9e5e14b56381a72
|
{
"intermediate": 0.416375070810318,
"beginner": 0.1929364949464798,
"expert": 0.39068838953971863
}
|
44,415
|
Hello
|
6d2f063b00acbd5361740b126efe7e05
|
{
"intermediate": 0.3123404085636139,
"beginner": 0.2729349136352539,
"expert": 0.4147246778011322
}
|
44,416
|
ha habido un error de conexión entre nosotros. te pongo al día de nuestra última conversación:
YO: dónde debería implementar el comando ‘_move_to_cache’?:
from future import annotations
import shutil
import os
def _move_to_cache(file_path, cache_dir):
# Comprueba si el archivo ya está en el directorio deseado
if os.path.commonpath([file_path, cache_dir]) == cache_dir:
return file_path
else:
# Intenta copiar el archivo al cache_dir en lugar de moverlo
try:
file_name = os.path.basename(file_path)
new_file_path = os.path.join(cache_dir, file_name)
shutil.copy(file_path, new_file_path)
return new_file_path
except Exception as e:
# Manejar la excepción según sea necesario
print(f"No se pudo copiar el archivo a la caché debido a: {e}“)
# Dependiendo de tu caso, podrías querer devolver la ruta original
# o manejar de otra manera este fallo
return file_path
import base64
import hashlib
import json
import logging
import os
import shutil
import subprocess
import tempfile
import warnings
from io import BytesIO
from pathlib import Path
from typing import TYPE_CHECKING, Any
import httpx
import numpy as np
from gradio_client import utils as client_utils
from PIL import Image, ImageOps, PngImagePlugin
from gradio import utils, wasm_utils
from gradio.data_classes import FileData, GradioModel, GradioRootModel
from gradio.utils import abspath, get_upload_folder, is_in_or_equal
with warnings.catch_warnings():
warnings.simplefilter(“ignore”) # Ignore pydub warning if ffmpeg is not installed
from pydub import AudioSegment
log = logging.getLogger(name)
if TYPE_CHECKING:
from gradio.blocks import Block
#########################
# GENERAL
#########################
def to_binary(x: str | dict) -> bytes:
“”“Converts a base64 string or dictionary to a binary string that can be sent in a POST.””“
if isinstance(x, dict):
if x.get(“data”):
base64str = x[“data”]
else:
base64str = client_utils.encode_url_or_file_to_base64(x[“path”])
else:
base64str = x
return base64.b64decode(extract_base64_data(base64str))
def extract_base64_data(x: str) -> str:
“”“Just extracts the base64 data from a general base64 string.””“
return x.rsplit(”,“, 1)[-1]
#########################
# IMAGE PRE-PROCESSING
#########################
def encode_plot_to_base64(plt, format: str = “png”):
fmt = format or “png”
with BytesIO() as output_bytes:
plt.savefig(output_bytes, format=fmt)
bytes_data = output_bytes.getvalue()
base64_str = str(base64.b64encode(bytes_data), “utf-8”)
return output_base64(base64_str, fmt)
def get_pil_exif_bytes(pil_image):
if “exif” in pil_image.info:
return pil_image.info[“exif”]
def get_pil_metadata(pil_image):
# Copy any text-only metadata
metadata = PngImagePlugin.PngInfo()
for key, value in pil_image.info.items():
if isinstance(key, str) and isinstance(value, str):
metadata.add_text(key, value)
return metadata
def encode_pil_to_bytes(pil_image, format=“png”):
with BytesIO() as output_bytes:
if format == “png”:
params = {“pnginfo”: get_pil_metadata(pil_image)}
else:
exif = get_pil_exif_bytes(pil_image)
params = {“exif”: exif} if exif else {}
pil_image.save(output_bytes, format, params)
return output_bytes.getvalue()
def encode_pil_to_base64(pil_image, format=“png”):
bytes_data = encode_pil_to_bytes(pil_image, format)
base64_str = str(base64.b64encode(bytes_data), “utf-8”)
return output_base64(base64_str, format)
def encode_array_to_base64(image_array, format=“png”):
with BytesIO() as output_bytes:
pil_image = Image.fromarray(_convert(image_array, np.uint8, force_copy=False))
pil_image.save(output_bytes, format)
bytes_data = output_bytes.getvalue()
base64_str = str(base64.b64encode(bytes_data), “utf-8”)
return output_base64(base64_str, format)
def output_base64(data, format=None) -> str:
return f"data:image/{format or ‘png’};base64,{data}“
def hash_file(file_path: str | Path, chunk_num_blocks: int = 128) -> str:
sha1 = hashlib.sha1()
with open(file_path, “rb”) as f:
for chunk in iter(lambda: f.read(chunk_num_blocks * sha1.block_size), b”“):
sha1.update(chunk)
return sha1.hexdigest()
def hash_url(url: str) -> str:
sha1 = hashlib.sha1()
sha1.update(url.encode(“utf-8”))
return sha1.hexdigest()
def hash_bytes(bytes: bytes):
sha1 = hashlib.sha1()
sha1.update(bytes)
return sha1.hexdigest()
def hash_base64(base64_encoding: str, chunk_num_blocks: int = 128) -> str:
sha1 = hashlib.sha1()
for i in range(0, len(base64_encoding), chunk_num_blocks * sha1.block_size):
data = base64_encoding[i : i + chunk_num_blocks * sha1.block_size]
sha1.update(data.encode(“utf-8”))
return sha1.hexdigest()
def save_pil_to_cache(
img: Image.Image,
cache_dir: str,
name: str = “image”,
format: str = “png”,
) -> str:
bytes_data = encode_pil_to_bytes(img, format)
temp_dir = Path(cache_dir) / hash_bytes(bytes_data)
temp_dir.mkdir(exist_ok=True, parents=True)
filename = str((temp_dir / f”{name}.{format}“).resolve())
(temp_dir / f”{name}.{format}“).resolve().write_bytes(bytes_data)
return filename
def save_img_array_to_cache(
arr: np.ndarray, cache_dir: str, format: str = “png”
) -> str:
pil_image = Image.fromarray(_convert(arr, np.uint8, force_copy=False))
return save_pil_to_cache(pil_image, cache_dir, format=format)
def save_audio_to_cache(
data: np.ndarray, sample_rate: int, format: str, cache_dir: str
) -> str:
temp_dir = Path(cache_dir) / hash_bytes(data.tobytes())
temp_dir.mkdir(exist_ok=True, parents=True)
filename = str((temp_dir / f"audio.{format}”).resolve())
audio_to_file(sample_rate, data, filename, format=format)
return filename
def save_bytes_to_cache(data: bytes, file_name: str, cache_dir: str) -> str:
path = Path(cache_dir) / hash_bytes(data)
path.mkdir(exist_ok=True, parents=True)
path = path / Path(file_name).name
path.write_bytes(data)
return str(path.resolve())
def save_file_to_cache(file_path: str | Path, cache_dir: str) -> str:
“”“Returns a temporary file path for a copy of the given file path if it does
not already exist. Otherwise returns the path to the existing temp file.”“”
temp_dir = hash_file(file_path)
temp_dir = Path(cache_dir) / temp_dir
temp_dir.mkdir(exist_ok=True, parents=True)
name = client_utils.strip_invalid_filename_characters(Path(file_path).name)
full_temp_file_path = str(abspath(temp_dir / name))
if not Path(full_temp_file_path).exists():
shutil.copy2(file_path, full_temp_file_path)
return full_temp_file_path
def save_url_to_cache(url: str, cache_dir: str) -> str:
“”“Downloads a file and makes a temporary file path for a copy if does not already
exist. Otherwise returns the path to the existing temp file.”“”
temp_dir = hash_url(url)
temp_dir = Path(cache_dir) / temp_dir
temp_dir.mkdir(exist_ok=True, parents=True)
name = client_utils.strip_invalid_filename_characters(Path(url).name)
full_temp_file_path = str(abspath(temp_dir / name))
if not Path(full_temp_file_path).exists():
with httpx.stream(“GET”, url, follow_redirects=True) as r, open(
full_temp_file_path, “wb”
) as f:
for chunk in r.iter_raw():
f.write(chunk)
return full_temp_file_path
def save_base64_to_cache(
base64_encoding: str, cache_dir: str, file_name: str | None = None
) -> str:
“”“Converts a base64 encoding to a file and returns the path to the file if
the file doesn’t already exist. Otherwise returns the path to the existing file.
“””
temp_dir = hash_base64(base64_encoding)
temp_dir = Path(cache_dir) / temp_dir
temp_dir.mkdir(exist_ok=True, parents=True)
guess_extension = client_utils.get_extension(base64_encoding)
if file_name:
file_name = client_utils.strip_invalid_filename_characters(file_name)
elif guess_extension:
file_name = f"file.{guess_extension}"
else:
file_name = “file”
full_temp_file_path = str(abspath(temp_dir / file_name)) # type: ignore
if not Path(full_temp_file_path).exists():
data, _ = client_utils.decode_base64_to_binary(base64_encoding)
with open(full_temp_file_path, “wb”) as fb:
fb.write(data)
return full_temp_file_path
def move_resource_to_block_cache(
url_or_file_path: str | Path | None, block: Block
) -> str | None:
“”“This method has been replaced by Block.move_resource_to_block_cache(), but is
left here for backwards compatibility for any custom components created in Gradio 4.2.0 or earlier.
“””
return block.move_resource_to_block_cache(url_or_file_path)
def move_files_to_cache(
data: Any,
block: Block,
postprocess: bool = False,
check_in_upload_folder=False,
keep_in_cache=False,
) -> dict:
“”“Move any files in data to cache and (optionally), adds URL prefixes (/file=…) needed to access the cached file.
Also handles the case where the file is on an external Gradio app (/proxy=…).
Runs after .postprocess() and before .preprocess().
Args:
data: The input or output data for a component. Can be a dictionary or a dataclass
block: The component whose data is being processed
postprocess: Whether its running from postprocessing
check_in_upload_folder: If True, instead of moving the file to cache, checks if the file is in already in cache (exception if not).
keep_in_cache: If True, the file will not be deleted from cache when the server is shut down.
“””
def _move_to_cache(d: dict):
payload = FileData(d)
# If the gradio app developer is returning a URL from
# postprocess, it means the component can display a URL
# without it being served from the gradio server
# This makes it so that the URL is not downloaded and speeds up event processing
if payload.url and postprocess and client_utils.is_http_url_like(payload.url):
payload.path = payload.url
elif utils.is_static_file(payload):
pass
elif not block.proxy_url:
# If the file is on a remote server, do not move it to cache.
if check_in_upload_folder and not client_utils.is_http_url_like(
payload.path
):
path = os.path.abspath(payload.path)
if not is_in_or_equal(path, get_upload_folder()):
raise ValueError(
f"File {path} is not in the upload folder and cannot be accessed.“
)
temp_file_path = block.move_resource_to_block_cache(payload.path)
if temp_file_path is None:
raise ValueError(“Did not determine a file path for the resource.”)
payload.path = temp_file_path
if keep_in_cache:
block.keep_in_cache.add(payload.path)
url_prefix = “/stream/” if payload.is_stream else “/file=”
if block.proxy_url:
proxy_url = block.proxy_url.rstrip(”/“)
url = f”/proxy={proxy_url}{url_prefix}{payload.path}“
elif client_utils.is_http_url_like(payload.path) or payload.path.startswith(
f”{url_prefix}“
):
url = payload.path
else:
url = f”{url_prefix}{payload.path}"
payload.url = url
return payload.model_dump()
if isinstance(data, (GradioRootModel, GradioModel)):
data = data.model_dump()
return client_utils.traverse(data, _move_to_cache, client_utils.is_file_obj)
def add_root_url(data: dict | list, root_url: str, previous_root_url: str | None):
def _add_root_url(file_dict: dict):
if previous_root_url and file_dict[“url”].startswith(previous_root_url):
file_dict[“url”] = file_dict[“url”][len(previous_root_url) :]
elif client_utils.is_http_url_like(file_dict[“url”]):
return file_dict
file_dict[“url”] = f’{root_url}{file_dict[“url”]}'
return file_dict
return client_utils.traverse(data, add_root_url, client_utils.is_file_obj_with_url)
def resize_and_crop(img, size, crop_type=“center”):
“”“
Resize and crop an image to fit the specified size.
args:
size: (width, height) tuple. Pass None for either width or height
to only crop and resize the other.
crop_type: can be ‘top’, ‘middle’ or ‘bottom’, depending on this
value, the image will cropped getting the ‘top/left’, ‘middle’ or
‘bottom/right’ of the image to fit the size.
raises:
ValueError: if an invalid crop_type is provided.
“””
if crop_type == “top”:
center = (0, 0)
elif crop_type == “center”:
center = (0.5, 0.5)
else:
raise ValueError
resize = list(size)
if size[0] is None:
resize[0] = img.size[0]
if size[1] is None:
resize[1] = img.size[1]
return ImageOps.fit(img, resize, centering=center) # type: ignore
##################
# Audio
##################
def audio_from_file(filename, crop_min=0, crop_max=100):
try:
audio = AudioSegment.from_file(filename)
except FileNotFoundError as e:
isfile = Path(filename).is_file()
msg = (
f"Cannot load audio from file: {'ffprobe' if isfile else filename} not found.“
+ " Please install ffmpeg in your system to use non-WAV audio file formats”
" and make sure ffprobe is in your PATH."
if isfile
else “”
)
raise RuntimeError(msg) from e
if crop_min != 0 or crop_max != 100:
audio_start = len(audio) * crop_min / 100
audio_end = len(audio) * crop_max / 100
audio = audio[audio_start:audio_end]
data = np.array(audio.get_array_of_samples())
if audio.channels > 1:
data = data.reshape(-1, audio.channels)
return audio.frame_rate, data
def audio_to_file(sample_rate, data, filename, format=“wav”):
if format == “wav”:
data = convert_to_16_bit_wav(data)
audio = AudioSegment(
data.tobytes(),
frame_rate=sample_rate,
sample_width=data.dtype.itemsize,
channels=(1 if len(data.shape) == 1 else data.shape[1]),
)
file = audio.export(filename, format=format)
file.close() # type: ignore
def convert_to_16_bit_wav(data):
# Based on: https://docs.scipy.org/doc/scipy/reference/generated/scipy.io.wavfile.write.html
warning = “Trying to convert audio automatically from {} to 16-bit int format.”
if data.dtype in [np.float64, np.float32, np.float16]:
warnings.warn(warning.format(data.dtype))
data = data / np.abs(data).max()
data = data * 32767
data = data.astype(np.int16)
elif data.dtype == np.int32:
warnings.warn(warning.format(data.dtype))
data = data / 65536
data = data.astype(np.int16)
elif data.dtype == np.int16:
pass
elif data.dtype == np.uint16:
warnings.warn(warning.format(data.dtype))
data = data - 32768
data = data.astype(np.int16)
elif data.dtype == np.uint8:
warnings.warn(warning.format(data.dtype))
data = data * 257 - 32768
data = data.astype(np.int16)
elif data.dtype == np.int8:
warnings.warn(warning.format(data.dtype))
data = data * 256
data = data.astype(np.int16)
else:
raise ValueError(
“Audio data cannot be converted automatically from “
f”{data.dtype} to 16-bit int format.”
)
return data
##################
# OUTPUT
##################
def convert(image, dtype, force_copy=False, uniform=False):
“”“
Adapted from: https://github.com/scikit-image/scikit-image/blob/main/skimage/util/dtype.py#L510-L531
Convert an image to the requested data-type.
Warnings are issued in case of precision loss, or when negative values
are clipped during conversion to unsigned integer types (sign loss).
Floating point values are expected to be normalized and will be clipped
to the range [0.0, 1.0] or [-1.0, 1.0] when converting to unsigned or
signed integers respectively.
Numbers are not shifted to the negative side when converting from
unsigned to signed integer types. Negative values will be clipped when
converting to unsigned integers.
Parameters
----------
image : ndarray
Input image.
dtype : dtype
Target data-type.
force_copy : bool, optional
Force a copy of the data, irrespective of its current dtype.
uniform : bool, optional
Uniformly quantize the floating point range to the integer range.
By default (uniform=False) floating point values are scaled and
rounded to the nearest integers, which minimizes back and forth
conversion errors.
… versionchanged :: 0.15
_convert no longer warns about possible precision or sign
information loss. See discussions on these warnings at:
https://github.com/scikit-image/scikit-image/issues/2602
https://github.com/scikit-image/scikit-image/issues/543#issuecomment-208202228
https://github.com/scikit-image/scikit-image/pull/3575
References
----------
… [1] DirectX data conversion rules.
https://msdn.microsoft.com/en-us/library/windows/desktop/dd607323(v=vs.85).aspx
… [2] Data Conversions. In “OpenGL ES 2.0 Specification v2.0.25”,
pp 7-8. Khronos Group, 2010.
… [3] Proper treatment of pixels as integers. A.W. Paeth.
In “Graphics Gems I”, pp 249-256. Morgan Kaufmann, 1990.
… [4] Dirty Pixels. J. Blinn. In “Jim Blinn’s corner: Dirty Pixels”,
pp 47-57. Morgan Kaufmann, 1998.
“””
dtype_range = {
bool: (False, True),
np.bool: (False, True),
np.bool8: (False, True), # type: ignore
float: (-1, 1),
np.float: (-1, 1),
np.float16: (-1, 1),
np.float32: (-1, 1),
np.float64: (-1, 1),
}
def _dtype_itemsize(itemsize, *dtypes):
“”“Return first of dtypes with itemsize greater than itemsize
Parameters
----------
itemsize: int
The data type object element size.
Other Parameters
----------------
*dtypes:
Any Object accepted by np.dtype to be converted to a data
type object
Returns
-------
dtype: data type object
First of dtypes with itemsize greater than itemsize.
“””
return next(dt for dt in dtypes if np.dtype(dt).itemsize >= itemsize)
def _dtype_bits(kind, bits, itemsize=1):
“”“Return dtype of kind that can store a bits wide unsigned int
Parameters:
kind: str
Data type kind.
bits: int
Desired number of bits.
itemsize: int
The data type object element size.
Returns
-------
dtype: data type object
Data type of kind that can store a bits wide unsigned int
“””
s = next(
i
for i in (itemsize,) + (2, 4, 8)
if bits < (i * 8) or (bits == (i * 8) and kind == “u”)
)
return np.dtype(kind + str(s))
def _scale(a, n, m, copy=True):
“”“Scale an array of unsigned/positive integers from n to m bits.
Numbers can be represented exactly only if m is a multiple of n.
Parameters
----------
a : ndarray
Input image array.
n : int
Number of bits currently used to encode the values in a.
m : int
Desired number of bits to encode the values in out.
copy : bool, optional
If True, allocates and returns new array. Otherwise, modifies
a in place.
Returns
-------
out : array
Output image array. Has the same kind as a.
“””
kind = a.dtype.kind
if n > m and a.max() < 2m:
return a.astype(_dtype_bits(kind, m))
elif n == m:
return a.copy() if copy else a
elif n > m:
# downscale with precision loss
if copy:
b = np.empty(a.shape, _dtype_bits(kind, m))
np.floor_divide(a, 2 ** (n - m), out=b, dtype=a.dtype, casting=“unsafe”)
return b
else:
a //= 2 ** (n - m)
return a
elif m % n == 0:
# exact upscale to a multiple of n bits
if copy:
b = np.empty(a.shape, _dtype_bits(kind, m))
np.multiply(a, (2m - 1) // (2n - 1), out=b, dtype=b.dtype)
return b
else:
a = a.astype(_dtype_bits(kind, m, a.dtype.itemsize), copy=False)
a *= (2m - 1) // (2n - 1)
return a
else:
# upscale to a multiple of n bits,
# then downscale with precision loss
o = (m // n + 1) * n
if copy:
b = np.empty(a.shape, _dtype_bits(kind, o))
np.multiply(a, (2o - 1) // (2n - 1), out=b, dtype=b.dtype)
b //= 2 ** (o - m)
return b
else:
a = a.astype(_dtype_bits(kind, o, a.dtype.itemsize), copy=False)
a *= (2o - 1) // (2**n - 1)
a //= 2 ** (o - m)
return a
image = np.asarray(image)
dtypeobj_in = image.dtype
dtypeobj_out = np.dtype(“float64”) if dtype is np.floating else np.dtype(dtype)
dtype_in = dtypeobj_in.type
dtype_out = dtypeobj_out.type
kind_in = dtypeobj_in.kind
kind_out = dtypeobj_out.kind
itemsize_in = dtypeobj_in.itemsize
itemsize_out = dtypeobj_out.itemsize
# Below, we do an issubdtype check. Its purpose is to find out
# whether we can get away without doing any image conversion. This happens
# when:
#
# - the output and input dtypes are the same or
# - when the output is specified as a type, and the input dtype
# is a subclass of that type (e.g. np.floating will allow
# float32 and float64 arrays through)
if np.issubdtype(dtype_in, np.obj2sctype(dtype)):
if force_copy:
image = image.copy()
return image
if kind_in in “ui”:
imin_in = np.iinfo(dtype_in).min
imax_in = np.iinfo(dtype_in).max
if kind_out in “ui”:
imin_out = np.iinfo(dtype_out).min # type: ignore
imax_out = np.iinfo(dtype_out).max # type: ignore
# any -> binary
if kind_out == “b”:
return image > dtype_in(dtype_range[dtype_in][1] / 2)
# binary -> any
if kind_in == “b”:
result = image.astype(dtype_out)
if kind_out != “f”:
result *= dtype_out(dtype_range[dtype_out][1])
return result
# float -> any
if kind_in == “f”:
if kind_out == “f”:
# float -> float
return image.astype(dtype_out)
if np.min(image) < -1.0 or np.max(image) > 1.0:
raise ValueError(“Images of type float must be between -1 and 1.”)
# floating point -> integer
# use float type that can represent output integer type
computation_type = _dtype_itemsize(
itemsize_out, dtype_in, np.float32, np.float64
)
if not uniform:
if kind_out == “u”:
image_out = np.multiply(image, imax_out, dtype=computation_type) # type: ignore
else:
image_out = np.multiply(
image,
(imax_out - imin_out) / 2, # type: ignore
dtype=computation_type,
)
image_out -= 1.0 / 2.0
np.rint(image_out, out=image_out)
np.clip(image_out, imin_out, imax_out, out=image_out) # type: ignore
elif kind_out == “u”:
image_out = np.multiply(image, imax_out + 1, dtype=computation_type) # type: ignore
np.clip(image_out, 0, imax_out, out=image_out) # type: ignore
else:
image_out = np.multiply(
image,
(imax_out - imin_out + 1.0) / 2.0, # type: ignore
dtype=computation_type,
)
np.floor(image_out, out=image_out)
np.clip(image_out, imin_out, imax_out, out=image_out) # type: ignore
return image_out.astype(dtype_out)
# signed/unsigned int -> float
if kind_out == “f”:
# use float type that can exactly represent input integers
computation_type = _dtype_itemsize(
itemsize_in, dtype_out, np.float32, np.float64
)
if kind_in == “u”:
# using np.divide or np.multiply doesn’t copy the data
# until the computation time
image = np.multiply(image, 1.0 / imax_in, dtype=computation_type) # type: ignore
# DirectX uses this conversion also for signed ints
# if imin_in:
# np.maximum(image, -1.0, out=image)
else:
image = np.add(image, 0.5, dtype=computation_type)
image *= 2 / (imax_in - imin_in) # type: ignore
return np.asarray(image, dtype_out)
# unsigned int -> signed/unsigned int
if kind_in == “u”:
if kind_out == “i”:
# unsigned int -> signed int
image = _scale(image, 8 * itemsize_in, 8 * itemsize_out - 1)
return image.view(dtype_out)
else:
# unsigned int -> unsigned int
return _scale(image, 8 * itemsize_in, 8 * itemsize_out)
# signed int -> unsigned int
if kind_out == “u”:
image = _scale(image, 8 * itemsize_in - 1, 8 * itemsize_out)
result = np.empty(image.shape, dtype_out)
np.maximum(image, 0, out=result, dtype=image.dtype, casting=“unsafe”)
return result
# signed int -> signed int
if itemsize_in > itemsize_out:
return _scale(image, 8 * itemsize_in - 1, 8 * itemsize_out - 1)
image = image.astype(_dtype_bits(“i”, itemsize_out * 8))
image -= imin_in # type: ignore
image = _scale(image, 8 * itemsize_in, 8 * itemsize_out, copy=False)
image += imin_out # type: ignore
return image.astype(dtype_out)
def ffmpeg_installed() -> bool:
if wasm_utils.IS_WASM:
# TODO: Support ffmpeg in WASM
return False
return shutil.which(“ffmpeg”) is not None
def video_is_playable(video_filepath: str) -> bool:
“”“Determines if a video is playable in the browser.
A video is playable if it has a playable container and codec.
.mp4 -> h264
.webm -> vp9
.ogg -> theora
“””
from ffmpy import FFprobe, FFRuntimeError
try:
container = Path(video_filepath).suffix.lower()
probe = FFprobe(
global_options=”-show_format -show_streams -select_streams v -print_format json",
inputs={video_filepath: None},
)
output = probe.run(stderr=subprocess.PIPE, stdout=subprocess.PIPE)
output = json.loads(output[0])
video_codec = output[“streams”][0][“codec_name”]
return (container, video_codec) in [
(“.mp4”, “h264”),
(“.ogg”, “theora”),
(“.webm”, “vp9”),
]
# If anything goes wrong, assume the video can be played to not convert downstream
except (FFRuntimeError, IndexError, KeyError):
return True
def convert_video_to_playable_mp4(video_path: str) -> str:
“”“Convert the video to mp4. If something goes wrong return the original video.”“”
from ffmpy import FFmpeg, FFRuntimeError
try:
with tempfile.NamedTemporaryFile(delete=False) as tmp_file:
output_path = Path(video_path).with_suffix(“.mp4”)
shutil.copy2(video_path, tmp_file.name)
# ffmpeg will automatically use h264 codec (playable in browser) when converting to mp4
ff = FFmpeg(
inputs={str(tmp_file.name): None},
outputs={str(output_path): None},
global_options=“-y -loglevel quiet”,
)
ff.run()
except FFRuntimeError as e:
print(f"Error converting video to browser-playable format {str(e)}")
output_path = video_path
finally:
# Remove temp file
os.remove(tmp_file.name) # type: ignore
return str(output_path)
def get_video_length(video_path: str | Path):
if wasm_utils.IS_WASM:
raise wasm_utils.WasmUnsupportedError(
“Video duration is not supported in the Wasm mode.”
)
duration = subprocess.check_output(
[
“ffprobe”,
“-i”,
str(video_path),
“-show_entries”,
“format=duration”,
“-v”,
“quiet”,
“-of”,
“csv={}”.format(“p=0”),
]
)
duration_str = duration.decode(“utf-8”).strip()
duration_float = float(duration_str)
return duration_float
TÚ: El ejemplo de código que proporcionas es una mezcla de varias funcionalidades y utilidades relacionadas principalmente con el procesamiento de archivos, audio, imagen y video para su uso, posiblemente, en una aplicación web o un sistema que trabaja intensamente con contenido multimedia. La función _move_to_cache(file_path, cache_dir) está diseñada para mover (o en tu caso, copiar) archivos a un directorio de caché especificado.
Para decidir en qué lugar deberías implementar el comando _move_to_cache, es importante considerar el contexto de uso y el flujo de trabajo de la aplicación. Basándome en el código que proporcionas, el cual parece estar relacionado con la manipulación y la preparación de datos para su utilización o presentación, existen varios puntos donde podría ser relevante el uso de esta función:
1. Durante la carga de recursos: Cuando se cargan archivos (ej. imágenes, audio, video) en tu aplicación, puede ser deseable copiar estos archivos a un directorio de caché para un acceso más rápido en el futuro. Esto es especialmente útil si los archivos se van a procesar o convertir de alguna forma.
2. Después de procesar contenidos: Si tu aplicación realiza algún procesamiento en archivos, como conversión de formatos, redimensionamiento de imágenes, etc., podrías querer almacenar el resultado en caché para evitar tener que repetir el procesamiento.
3. Antes de servir archivos a los usuarios: Si estás sirviendo contenido estático o dinámico a los usuarios y este contenido cambia poco con el tiempo, implementar _move_to_cache antes de la entrega podría ayudar a mejorar la eficiencia, reduciendo la carga en los servidores y acelerando la entrega de contenido.
Dentro del contexto del código que proporcionas, aquí hay algunas ideas más específicas:
- Después de generar o modificar imágenes (ver save_pil_to_cache, save_img_array_to_cache).
- Al guardar archivos de audio o video procesados (ver save_audio_to_cache).
- Tras completar la descarga y antes de la entrega de archivos externos (ver save_url_to_cache, save_file_to_cache).
- Antes de devolver los resultados de las funciones que procesan archivos base64 (ver save_base64_to_cache).
Por último, asegúrate de considerar el manejo de errores y la limpieza de la caché como parte de la implementación para evitar el crecimiento descontrolado del almacenamiento y otros posibles problemas.
_______
Tras esta conversación, y el error de conexión, te indico que me interesaría saber en que lugar del código debo insertar el comando _move_to_cache_ teniendo en cuenta que me interesa que sea respecto al punto '1. Durante la carga de recusrsos' que me indicas anteriormente.
|
12dc8af86be5946166f52c6bfcdfb187
|
{
"intermediate": 0.4470202922821045,
"beginner": 0.45251667499542236,
"expert": 0.10046305507421494
}
|
44,417
|
import pygame
import random
import math
# Initialize pygame and create a screen object
pygame.init()
screen = pygame.display.set_mode((1000, 800))
# Define colors
BLACK = (0, 0, 0)
RED = (255, 0, 0)
# Define grid size
GRID_WIDTH = 21
GRID_HEIGHT = 17
# Initialize the invisible variable
invisible = False
# Define initial floor position
FLOOR_START_ROW = GRID_HEIGHT - 2
FLOOR_END_ROW = GRID_HEIGHT - 1
pygame.display.set_caption('100% no luck')
# Load the images for the background, the player, and the boss
# Ensure that these images are present in your project directory
try:
background = pygame.image.load('level_1_background.jpeg')
player_image = pygame.image.load('player1_back.png')
invisibility_cloak_image = pygame.image.load('invisibility_cloak.png')
grappling_hook_image = pygame.image.load('grappling_hook.png')
katana_image = pygame.image.load('katana.png')
freezing_ray_image = pygame.image.load('freezing_ray.png')
speed_pill_image = pygame.image.load('speed_pill.jpeg')
bouncy_shoes_image = pygame.image.load('bouncy_shoes.png')
key_image = pygame.image.load('key.png')
tsunami_maker_image = pygame.image.load('tsunami_maker.png')
laser_beam_image = pygame.image.load('laser_beam.png')
go_kart_image = pygame.image.load('go_kart.jpeg')
revival_kit_image = pygame.image.load('revival_kit.jpeg')
except pygame.error as e:
print("Cannot load images:", e)
raise SystemExit
# Define the colors for the text
WHITE = (255, 255, 255)
# Define the font for the text
font = pygame.font.SysFont('Arial', 32)
# Define the text for the intro and the tools
intro_text = "Welcome to 100% no luck, a game where you have to use smart logic and some luck to beat the dungeon. You will spawn with 3 tools out of a possible 15 tools randomized. Each tool has a different effect and can help you or hinder you depending on the situation. You have to think carefully about how to use your tools and when to use them. The dungeon has many obstacles and enemies that you have to overcome. The goal is to reach the end of the dungeon and defeat the boss. Good luck!"
tools_text = ["Invisibility cloak: Makes you invisible for 10 seconds. Useful for sneaking past enemies or traps.",
"Grappling hook: Allows you to swing across gaps or pull objects towards you.",
"Katana: A sharp sword that can cut through anything. Useful for fighting enemies or breaking barriers.",
"Freeze ray: A device that can freeze anything in its path. Useful for stopping enemies or creating platforms.",
"Bouncy shoes: Shoes that make you jump higher and farther. Useful for reaching high places or avoiding obstacles.",
"Key: A key that can unlock any door or chest. Useful for accessing hidden areas or treasures.",
"Go kart: A vehicle that can move fast and run over anything. Useful for escaping enemies or crossing large distances.",
"Tsunami maker: A device that can create a huge wave of water. Useful for washing away enemies or filling gaps.",
"Laser beam: A device that can shoot a powerful laser. Useful for destroying enemies or barriers.",
"Speed pill: A pill that can make you move faster for 10 seconds. Useful for dodging enemies or traps.",
"Revival kit: A kit that can revive you once if you die. Useful for surviving fatal situations."]
def show_intro():
intro_text = "Welcome to 100% no luck, a game where you have to use smart logic and some luck to beat the dungeon. You will spawn with 3 tools out of a possible 15 tools randomized. Each tool has a different effect and can help you or hinder you depending on the situation. You have to think carefully about how to use your tools and when to use them. The dungeon has many obstacles and enemies that you have to overcome. The goal is to reach the end of the dungeon and defeat the boss. Good luck!"
# Wrap the intro text
intro_lines = []
max_width = 950 # Adjust as needed
words = intro_text.split()
current_line = words[0]
for word in words[1:]:
if font.size(current_line + ' ' + word)[0] < max_width:
current_line += ' ' + word
else:
intro_lines.append(current_line)
current_line = word
intro_lines.append(current_line)
current_line = 0
intro_complete = False
start_time = pygame.time.get_ticks()
while not intro_complete:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
screen.fill((0, 0, 0))
intro_surface = font.render(intro_lines[current_line], True, WHITE)
intro_rect = intro_surface.get_rect(center=(screen.get_width() // 2, screen.get_height() // 2))
screen.blit(intro_surface, intro_rect)
if pygame.time.get_ticks() - start_time > 2980:
current_line += 1
start_time = pygame.time.get_ticks()
if current_line == len(intro_lines):
intro_complete = True
pygame.display.flip()
pygame.time.Clock().tick(60)
screen.fill((0, 0, 0))
pygame.display.flip()
tools_title_surface = font.render("Selected Tools:", True, WHITE)
tools_title_rect = tools_title_surface.get_rect(center=(screen.get_width() // 2, 100))
screen.blit(tools_title_surface, tools_title_rect)
pygame.display.flip()
pygame.time.delay(1000)
available_buttons = ['v', 'b', 'n', 'x', 'y', 'z'] # Add more buttons if needed
selected_tools = random.sample(tools_text, 3)
# Assign buttons to the selected tools
button_assignments = available_buttons[:3] # Take the first three buttons
button_assigned_functions = [tool_functions[tools_text.index(tool)] for tool in selected_tools]
# Wrap the tool descriptions and display them with their assigned buttons
wrapped_tools = []
for i, tool_desc in enumerate(selected_tools):
tool_lines = []
current_line = f"{button_assignments[i]}: {tool_desc.split()[0]}"
for word in tool_desc.split()[1:]:
if font.size(current_line + ' ' + word)[0] < max_width:
current_line += ' ' + word
else:
tool_lines.append(current_line)
current_line = word
tool_lines.append(current_line)
wrapped_tools.append(tool_lines)
selected_tools_surface = [font.render(line, True, WHITE) for tool_lines in wrapped_tools for line in tool_lines]
for i, tool_surface in enumerate(selected_tools_surface):
tool_rect = tool_surface.get_rect(center=(screen.get_width() // 2, 200 + i * 50))
screen.blit(tool_surface, tool_rect)
pygame.display.flip()
start_time = pygame.time.get_ticks()
while pygame.time.get_ticks() - start_time < 2000:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
screen.fill((0, 0, 0))
pygame.display.flip()
return button_assignments, button_assigned_functions
# Define the logic for each tool as a function
def invisibility_cloak(player_rect):
# Set a global variable to indicate that the player is invisible
global invisible
invisible = True
# Set a timer to make the player visible again after 10 seconds
pygame.time.set_timer(pygame.USEREVENT, 10000)
def grappling_hook(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the distance and the angle between the mouse and the player
distance = ((mouse_x - player_x) ** 2 + (mouse_y - player_y) ** 2) ** 0.5
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, BLACK, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the mouse is over a gap or an object
if mouse_x > 600 and mouse_x < 700 and mouse_y > 300 and mouse_y < 400:
# If the mouse is over a gap, move the player towards the mouse
player_rect.centerx += math.cos(angle) * 10
player_rect.centery += math.sin(angle) * 10
elif mouse_x > 700 and mouse_x < 800 and mouse_y > 200 and mouse_y < 300:
# If the mouse is over an object, move the object towards the player
object_rect.centerx -= math.cos(angle) * 10
object_rect.centery -= math.sin(angle) * 10
def katana(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the angle between the mouse and the player
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Create a line surface or rect from the player to the mouse
line_length = math.hypot(mouse_x - player_x, mouse_y - player_y)
line_surf = pygame.Surface((line_length, 5), pygame.SRCALPHA)
line_surf.fill(RED)
line_rect = line_surf.get_rect()
line_rect.center = player_rect.center
# Rotate the line surface
rotated_line_surf = pygame.transform.rotate(line_surf, math.degrees(angle))
# Create a sprite for the rotated line
line_sprite = pygame.sprite.Sprite()
line_sprite.image = rotated_line_surf
line_sprite.rect = rotated_line_surf.get_rect(center=line_rect.center)
# Check if the line intersects with an enemy or a barrier
collided_enemies = pygame.sprite.spritecollide(line_sprite, enemies, True)
collided_barriers = pygame.sprite.spritecollide(line_sprite, barriers, True)
# Draw the rotated line on the screen
screen.blit(rotated_line_surf, line_sprite.rect)
def bouncy_shoes(player_rect):
# Set a global variable to indicate that the player has bouncy shoes
global bouncy
bouncy = True
# Increase the player's jump velocity
player_jump_vel = 20
def key(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the distance between the mouse and the player
distance = ((mouse_x - player_x) ** 2 + (mouse_y - player_y) ** 2) ** 0.5
# Check if the mouse is over a door or a chest
if pygame.sprite.spritecollideany(mouse, doors) or pygame.sprite.spritecollideany(mouse, chests):
# If the mouse is over a door or a chest, unlock it and open it
pygame.sprite.spritecollide(mouse, doors, True)
pygame.sprite.spritecollide(mouse, chests, True)
# If the chest contains a tool, add it to the player's inventory
if chest.tool:
inventory.append(chest.tool)
def go_kart(player_rect):
# Set a global variable to indicate that the player is in a go kart
global go_kart
go_kart = True
# Increase the player's speed and size
player_speed = 15
player_rect.inflate_ip(50, 50)
# Load the image for the go kart
go_kart = pygame.image.load('go_kart.png')
# Draw the go kart over the player
screen.blit(go_kart, player_rect)
# Check if the player collides with an enemy or a barrier
if pygame.sprite.spritecollideany(player, enemies) or pygame.sprite.spritecollideany(player, barriers):
# If the player collides with an enemy or a barrier, run over it and destroy it
pygame.sprite.spritecollide(player, enemies, True)
pygame.sprite.spritecollide(player, barriers, True)
def freeze_ray(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the angle between the mouse and the player
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, BLUE, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the line intersects with an enemy or a platform
if pygame.sprite.spritecollideany(line, enemies) or pygame.sprite.spritecollideany(line, platforms):
# If the line intersects with an enemy or a platform, freeze it
pygame.sprite.spritecollide(line, enemies, False, freeze)
pygame.sprite.spritecollide(line, platforms, False, freeze)
def freeze(sprite):
# Change the sprite's image to a frozen version
sprite.image = pygame.image.load(sprite.name + '_frozen.png')
# Set the sprite's frozen attribute to True
sprite.frozen = True
def tsunami_maker(player_rect):
# Set a global variable to indicate that the player has used the tsunami maker
global tsunami
tsunami = True
# Load the image for the wave
wave = pygame.image.load('wave.png')
# Create a rect for the wave
wave_rect = wave.get_rect()
# Set the wave's initial position at the left edge of the screen
wave_rect.left = 0
# Set the wave's speed
wave_speed = 10
# Draw the wave on the screen
screen.blit(wave, wave_rect)
# Move the wave to the right
wave_rect.x += wave_speed
# Check if the wave collides with an enemy or a gap
if pygame.sprite.spritecollideany(wave, enemies) or pygame.sprite.spritecollideany(wave, gaps):
# If the wave collides with an enemy or a gap, wash it away
pygame.sprite.spritecollide(wave, enemies, True)
pygame.sprite.spritecollide(wave, gaps, True, fill)
def fill(sprite):
# Change the sprite's image to a water version
sprite.image = pygame.image.load(sprite.name + '_water.png')
# Set the sprite's filled attribute to True
sprite.filled = True
def laser_beam(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the angle between the mouse and the player
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, YELLOW, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the line intersects with an enemy or a barrier
if pygame.sprite.spritecollideany(line, enemies) or pygame.sprite.spritecollideany(line, barriers):
# If the line intersects with an enemy or a barrier, destroy it
pygame.sprite.spritecollide(line, enemies, True)
pygame.sprite.spritecollide(line, barriers, True)
def speed_pill(player_rect):
# Set a global variable to indicate that the player has used the speed pill
global speed
speed = True
# Set a timer to make the player normal again after 10 seconds
pygame.time.set_timer(pygame.USEREVENT + 1, 10000)
# Increase the player's speed
player_speed = 10
def revival_kit(player_rect):
# Set a global variable to indicate that the player has a revival kit
global revival
revival = True
# Check if the player's health is zero
if player_health == 0:
# If the player's health is zero, revive the player
player_health = 100
# Set the revival variable to False
revival = False
tool_functions = [invisibility_cloak, grappling_hook, katana, freeze_ray, bouncy_shoes, key,
go_kart, tsunami_maker, laser_beam, speed_pill, revival_kit]
def is_on_floor_or_stairs(player_rect):
"""
Check if the player is standing on a floor or stairs cell.
Returns True if standing on floor or stairs, False otherwise.
"""
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Check if the player is on the initial floor rows
if FLOOR_START_ROW <= player_rect.bottom // cell_height <= FLOOR_END_ROW:
for x in range(player_rect.left // cell_width, (player_rect.right + cell_width - 1) // cell_width):
if 0 <= x < GRID_WIDTH:
return True
return False
def draw_doors():
# Define the door's color
DOOR_COLOR = (139, 69, 19) # Saddle brown color
# Calculate the cell size based on the screen dimensions
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Draw door 1
door1_start_row = GRID_HEIGHT - 10
door1_end_row = GRID_HEIGHT - 13
door1_start_col = 10
door1_end_col = 11
for row in range(door1_start_row, door1_end_row - 1, -1):
for col in range(door1_start_col, door1_end_col + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, DOOR_COLOR, rect)
# Draw door 2
door2_start_row = GRID_HEIGHT - 3
door2_end_row = GRID_HEIGHT - 4
door2_start_col = 16
door2_end_col = 17
for row in range(door2_start_row, door2_end_row - 1, -1):
for col in range(door2_start_col, door2_end_col + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, DOOR_COLOR, rect)
def draw_floor():
# Define the floor's color
FLOOR_COLOR = (128, 64, 0) # Brown color
STAIRS_COLOR = (128, 128, 128) # Gray color
# Calculate the cell size based on the screen dimensions
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Draw the floor cells
for col in range(GRID_WIDTH):
for row in range(FLOOR_START_ROW, FLOOR_END_ROW + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, FLOOR_COLOR, rect)
enemies = pygame.sprite.Group()
barriers = pygame.sprite.Group()
platforms = pygame.sprite.Group()
doors = pygame.sprite.Group()
chests = pygame.sprite.Group()
gaps = pygame.sprite.Group()
tools = pygame.sprite.Group()
# Create some sprites and groups for the player
player_sprite = pygame.sprite.Sprite()
player_sprite.image = player_image
player_sprite.rect = player_sprite.image.get_rect()
player_sprite.rect.center = (100, 300)
# Create sprite groups
enemies = pygame.sprite.Group()
tools = pygame.sprite.Group() # Assuming tools are also Sprites
# Gravity constant
GRAVITY = 0.5
# Player properties
player_x = 100
player_y = 300
player_speed = 5
player_jump_vel = 10
player_vert_vel = 0 # Initial vertical velocity
player_health = 100
inventory = []
# Main game loop control
running = True
clock = pygame.time.Clock()
# Call show_intro() and get the button_assigned_functions list
button_assignments, button_assigned_functions = show_intro()
# Initialize player jumping state
player_is_jumping = False
# Create a rect for the player sprite
player_rect = player_sprite.rect
# In the main game loop
while running:
# 1. Handle events
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE and not player_is_jumping:
# Start jumping
player_is_jumping = True
player_vert_vel = -player_jump_vel
elif event.key == ord(button_assignments[0].upper()): # Use the first selected tool
try:
button_assigned_functions[0](player_sprite.rect) # Pass player_sprite.rect
except Exception as e:
print(f"Error calling tool function: {e}")
elif event.key == ord(button_assignments[1].upper()): # Use the second selected tool
try:
button_assigned_functions[1](player_sprite.rect) # Pass player_sprite.rect
except Exception as e:
print(f"Error calling tool function: {e}")
elif event.key == ord(button_assignments[2].upper()): # Use the third selected tool
try:
button_assigned_functions[2](player_sprite.rect) # Pass player_sprite.rect
except Exception as e:
print(f"Error calling tool function: {e}")
# 2. Update game state
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT]:
player_sprite.rect.x -= player_speed
if keys[pygame.K_RIGHT]:
player_sprite.rect.x += player_speed
if keys[pygame.K_UP]:
player_sprite.rect.y -= player_speed
if keys[pygame.K_DOWN]:
player_sprite.rect.y += player_speed
# Update player's vertical velocity and position if jumping
if player_is_jumping:
player_vert_vel += GRAVITY
player_sprite.rect.y += player_vert_vel
# Check if the player has landed on floor or stairs
if is_on_floor_or_stairs(player_sprite.rect):
player_is_jumping = False
player_vert_vel = 0
else:
# Apply gravity only if not on floor or stairs
if not is_on_floor_or_stairs(player_sprite.rect):
player_vert_vel += GRAVITY
player_sprite.rect.y += player_vert_vel
# Reset vertical velocity if on floor or stairs
if is_on_floor_or_stairs(player_sprite.rect):
player_vert_vel = 0
# Prevent the player from moving off screen
player_sprite.rect.clamp_ip(screen.get_rect())
# 3. Draw everything
screen.blit(background, (0, 0))
draw_floor()
draw_doors()
tools.draw(screen)
enemies.draw(screen)
screen.blit(player_sprite.image, player_sprite.rect) # Draw player
# Check if the player is invisible
if invisible:
# Draw the invisibility cloak image over the player
screen.blit(invisibility_cloak_image, player_sprite.rect)
# After drawing everything, update/flip the display
pygame.display.flip()
# 4. Cap the frame rate
clock.tick(60)
if __name__ == "__main__":
main() nothing happens when i press v, b, n ingame right now just trying to test out how they work and look before adding enemy sprites and collision, these should be able to work without this.
|
a51b3a35b0646d37aab17b5204d5e958
|
{
"intermediate": 0.3327173590660095,
"beginner": 0.3814488649368286,
"expert": 0.28583377599716187
}
|
44,418
|
Maximum update depth exceeded. This can happen when a component calls setState inside useEffect, but useEffect either doesn't have a dependency array, or one of the dependencies changes on every render.
at SingleProduct (http://localhost:3000/static/js/bundle.js:2323:90)
at RenderedRoute (http://localhost:3000/static/js/bundle.js:589354:5)
at Routes (http://localhost:3000/static/js/bundle.js:590045:5)
at Router (http://localhost:3000/static/js/bundle.js:589979:15)
at BrowserRouter (http://localhost:3000/static/js/bundle.js:587932:5)
at Le (http://localhost:3000/static/js/bundle.js:596755:60)
at EnvironmentProvider (http://localhost:3000/static/js/bundle.js:603129:5)
at ColorModeProvider (http://localhost:3000/static/js/bundle.js:602152:5)
at ThemeProvider (http://localhost:3000/static/js/bundle.js:13311:50)
at ThemeProvider (http://localhost:3000/static/js/bundle.js:605787:5)
at ChakraProvider (http://localhost:3000/static/js/bundle.js:603005:5)
at ChakraProvider2 (http://localhost:3000/static/js/bundle.js:603352:5)
at App
at CartProvider (http://localhost:3000/static/js/bundle.js:7066:3)
at FilterContextProvider (http://localhost:3000/static/js/bundle.js:7227:3)
at AppProvider (http://localhost:3000/static/js/bundle.js:7394:3)
at Auth0Provider (http://localhost:3000/static/js/bundle.js:12145:23) in the file: import styled from "styled-components";
import React, { useEffect, useState } from 'react'
import { useParams } from "react-router-dom";
import { useProductContext } from "./context/productContext";
import FormatPrice from "./Helpers/FormatPrice";
import PageNavigation from "./components/PageNavigation";
import MyImage from "./components/MyImage";
import { Container } from "./Container";
import {TbReplace, TbTruckDelivery} from 'react-icons/tb'
import {MdSecurity} from 'react-icons/md'
import Star from "./components/Star";
import AddToCart from "./components/AddToCart";
import Modal from './Popup';
import { motion } from "framer-motion";
import { fadeIn } from "./components/variants";
const SingleProduct = () => {
const [mainImageUrl, setMainImageUrl] = useState('');
const [open, setOpen] = React.useState(1);
const { getSingleProduct, isSingleLoading, singleProduct } = useProductContext();
const { id } = useParams();
useEffect(() => {
// Attempt to fetch product data as the component mounts
getSingleProduct(id);
}, [id, getSingleProduct]);
// React needs all hooks to be used in the same order
// between renders, even when the component returns early.
useEffect(() => {
// Ensure ‘image’ is loaded before attempting to set the main image URL
if (image && image.length > 0) {
setMainImageUrl(image[0]); // Assuming ‘image’ might be an array
}
}, [singleProduct]); // Depend on ‘singleProduct’ to re-trigger this effect when it updates
if (!singleProduct || isSingleLoading) {
// Early return should happen after all hooks have been called
return <div className="page_loading">Loading...</div>;
}
// Destructuring ‘singleProduct’ after the possibility of an early return has been checked
const { image, name, company, description, stock, price } = singleProduct;
const transitionVariants = {
initial: {
x: "100%",
width: "100%",
},
animate: {
x: "0%",
width: "0%",
},
exit: {
x: ["0%", "100%"],
width: ["0%", "100%"],
},
};
return <Wrapper mainImageUrl={mainImageUrl}>
<PageNavigation title={name} />
<Container className="container">
<motion.div
className="singleProda"
variants={fadeIn("down", 0.4)}
initial="hidden"
animate="show"
exit="hidden"
>
{/* Product Image */}
<div>
<MyImage imgs={image} setMainImageUrl={setMainImageUrl} />
</div>
{/* Product data */}
<div className="product-data mx-auto w-[50%]">
<h2>{name}</h2>
<p className="product-data-price ">
MRP:
<del>
<FormatPrice price={price + 250000}/>
</del>
</p>
<p className="product-data-price product-data-real-price">
Deal of the Day:
<FormatPrice price={price}/>
</p>
<p>{description}</p>
<Modal />
<div className="product-data-info">
<p>Available: <span>{stock > 0 ? "In Stock" : "Not Available"}</span></p>
<p>ID : <span> {id} </span></p>
<p>Brand : <span> {company} </span></p>
</div>
<hr />
{stock > 0 && <AddToCart product={singleProduct}/>}
</div>
</motion.div>
</Container>
</Wrapper>;
}
const Wrapper = styled.section`
background-image: url(${(props) => props.mainImageUrl});
background-repeat: no-repeat;
background-size: cover; // Or whatever fits your design best
background-position: center;
box-shadow: inset 0 0 0 2000px rgba(0, 0, 0, 0.85);
.container {
padding: 9rem 0;
}
header {
border-radius:none!important;
}
.product_images{
display:flex;
align-items:center;
}
.product-data {
display: flex;
flex-direction: column;
align-items: flex-start;
justify-content: center;
gap: 2rem;
.product-data-warranty {
width: 100%;
display: flex;
justify-content: space-between;
align-items: center;
border-bottom: 1px solid #ccc;
margin-bottom: 1rem;
.product-warranty-data {
text-align: center;
.warranty-icon {
background-color: rgba(220, 220, 220, 0.5);
border-radius: 50%;
width: 4rem;
height: 4rem;
padding: 0.6rem;
}
p {
font-size: 1.4rem;
padding-top: 0.4rem;
}
}
}
.product-data-price {
font-weight: bold;
}
.product-data-real-price {
color: ${({ theme }) => theme.colors.btn};
}
.product-data-info {
display: flex;
flex-direction: column;
gap: 1rem;
font-size: 1.8rem;
span {
font-weight: bold;
}
}
hr {
max-width: 100%;
width: 90%;
/* height: 0.2rem; */
border: 0.1rem solid #000;
color: red;
}
}
.product-images {
display: flex;
justify-content: center;
align-items: center;
}
@media (max-width: ${({ theme }) => theme.media.mobile}) {
padding: 0 2.4rem;
}
`;
export default SingleProduct;
|
f346872e63fb400395c8fc279f970777
|
{
"intermediate": 0.39598995447158813,
"beginner": 0.32037341594696045,
"expert": 0.2836366295814514
}
|
44,419
|
need best small js lib from github to easy save restore setting via get search params
|
a3057f1c9bbda578813cbe8cb73a3c1a
|
{
"intermediate": 0.6334154009819031,
"beginner": 0.19478990137577057,
"expert": 0.17179474234580994
}
|
44,420
|
I want you to create a boiler plate with Angular and Angular Signal
|
26b6fc2ee16b21f68c62a38a45b231a7
|
{
"intermediate": 0.5666594505310059,
"beginner": 0.28922879695892334,
"expert": 0.1441117823123932
}
|
44,421
|
git clone with https. repo is private
|
8608c73f979b781114c7cda3bc08c377
|
{
"intermediate": 0.3993101418018341,
"beginner": 0.27895691990852356,
"expert": 0.3217329978942871
}
|
44,422
|
i want to add a video background to the wrapper brand-section in my react app and have it stretched across the wrapper on dektop and mobile: import React from ‘react’
import styled from “styled-components”;
const Truested = () => {
return (
<Wrapper className=“brand-section”>
<div className=“container”>
<h3>Trusted By 1000+ Companies</h3>
<div className=“brand-section-slider”>
{/* my 1st img */}
<div className=“slide”>
<img
src=“https://raw.githubusercontent.com/solodev/infinite-logo-carousel/master/images/image2.png”
alt=“trusted-brands”
/>
</div>
<div className=“slide”>
<img
src=“https://raw.githubusercontent.com/solodev/infinite-logo-carousel/master/images/image3.png”
alt=“trusted-brands”
/>
</div>
<div className=“slide”>
<img
src=“https://raw.githubusercontent.com/solodev/infinite-logo-carousel/master/images/image4.png”
alt=“trusted-brands”
/>
</div>
<div className=“slide”>
<img
src=“https://raw.githubusercontent.com/solodev/infinite-logo-carousel/master/images/image6.png”
alt=“trusted-brands”
/>
</div>
<div className=“slide”>
<img
src=“https://raw.githubusercontent.com/solodev/infinite-logo-carousel/master/images/image8.png”
alt=“trusted-brands”
/>
</div>
</div>
</div>
</Wrapper>
)
}
const Wrapper = styled.section<br/> padding: 9rem 0;<br/> background-color: ${({ theme }) => theme.colors.bg};<br/> .brand-section {<br/> padding: 12rem 0 0 0;<br/> }<br/> h3 {<br/> text-align: center;<br/> text-transform: capitalize;<br/> color: white;<br/> font-size: 2rem;<br/> font-weight: bold;<br/> }<br/> img {<br/> min-width: 10rem;<br/> height: 10rem;<br/> }<br/> .brand-section-slider {<br/> margin-top: 3.2rem;<br/> margin-bottom: 7.2rem;<br/> display: flex;<br/> justify-content: space-between;<br/> align-items: center;<br/> flex-direction: row;<br/> }<br/> @media (max-width: ${({ theme }) => theme.media.mobile}) {<br/> .brand-section-slider {<br/> margin-top: 3.2rem;<br/> display: grid;<br/> grid-template-columns: 1fr 1fr;<br/> /* background-color: red; */<br/> text-align: center;<br/> }<br/> }<br/>;
export default Truested
|
1446b1f35c0efb224482e1640569d34a
|
{
"intermediate": 0.1826610416173935,
"beginner": 0.5618768334388733,
"expert": 0.25546208024024963
}
|
44,423
|
привет в чем может быть проблема
DirectoryNotFoundException: Could not find a part of the path 'D:\ProjectUnity\VRElectricalSafety\Assets\StreamingAssets\PDF\Theory\1'.
System.IO.Enumeration.FileSystemEnumerator`1[TResult].CreateDirectoryHandle (System.String path, System.Boolean ignoreNotFound) (at <d6232873609549b8a045fa15811a5bd3>:0)
System.IO.Enumeration.FileSystemEnumerator`1[TResult]..ctor (System.String directory, System.IO.EnumerationOptions options) (at <d6232873609549b8a045fa15811a5bd3>:0)
System.IO.Enumeration.FileSystemEnumerable`1+DelegateEnumerator[TResult]..ctor (System.IO.Enumeration.FileSystemEnumerable`1[TResult] enumerable) (at <d6232873609549b8a045fa15811a5bd3>:0)
System.IO.Enumeration.FileSystemEnumerable`1[TResult]..ctor (System.String directory, System.IO.Enumeration.FileSystemEnumerable`1+FindTransform[TResult] transform, System.IO.EnumerationOptions options) (at <d6232873609549b8a045fa15811a5bd3>:0)
System.IO.Enumeration.FileSystemEnumerableFactory.UserFiles (System.String directory, System.String expression, System.IO.EnumerationOptions options) (at <d6232873609549b8a045fa15811a5bd3>:0)
System.IO.Directory.InternalEnumeratePaths (System.String path, System.String searchPattern, System.IO.SearchTarget searchTarget, System.IO.EnumerationOptions options) (at <d6232873609549b8a045fa15811a5bd3>:0)
System.IO.Directory.GetFiles (System.String path, System.String searchPattern, System.IO.EnumerationOptions enumerationOptions) (at <d6232873609549b8a045fa15811a5bd3>:0)
System.IO.Directory.GetFiles (System.String path, System.String searchPattern, System.IO.SearchOption searchOption) (at <d6232873609549b8a045fa15811a5bd3>:0)
PDFUI.FindPdfFiles () (at Assets/Scripts/UI/PDF/PDFUI.cs:46)
PDFUI.Initialize () (at Assets/Scripts/UI/PDF/PDFUI.cs:39)
UI.Practice.UIHandlerQuest.Initialized () (at Assets/Scripts/UI/Practice/UIHandlerQuest.cs:29)
QuestHandler.Initialize () (at Assets/Scripts/Quest/QuestHandler.cs:36)
Infrastructure.EntryPoints.PracticeEntryPoint.CreateQuestHandler () (at Assets/Scripts/Infrastructure/EntryPoints/PracticeEntryPoint.cs:28)
Infrastructure.EntryPoints.PracticeEntryPoint.Initialize () (at Assets/Scripts/Infrastructure/EntryPoints/PracticeEntryPoint.cs:21)
Infrastructure.StateMachine.States.ApplicationStates.SessionState.OnSceneLoaded () (at Assets/Scripts/Infrastructure/StateMachine/States/ApplicationStates/SessionState.cs:40)
SceneLoader.SceneLoadService+<LoadingMultipleScenes>d__13.MoveNext () (at Assets/Scripts/Services/SceneLoading/SceneLoader.cs:103)
UnityEngine.SetupCoroutine.InvokeMoveNext (System.Collections.IEnumerator enumerator, System.IntPtr returnValueAddress) (at <685c48cf8f0b48abb797275c046dda6a>:0)
|
150daef5b788618a2eaae8e3c2fc236a
|
{
"intermediate": 0.1961836814880371,
"beginner": 0.5598097443580627,
"expert": 0.24400655925273895
}
|
44,424
|
in SDL, is there a way to get game controller instance ID, similar to how to get instance ID of josticks using SDL_JoystickGetDeviceInstanceID?
|
4a38f56b0725c860403bc96f24da4a36
|
{
"intermediate": 0.7155517339706421,
"beginner": 0.12816742062568665,
"expert": 0.15628084540367126
}
|
44,425
|
Is it possible to use vite with something like express or fastify? How would that work?
|
0c4a333f86065f1a38044cd8b6d9c3ad
|
{
"intermediate": 0.5496776700019836,
"beginner": 0.1568099409341812,
"expert": 0.29351240396499634
}
|
44,426
|
Hello for some reason does SharedAttackValues.isBeingAttacked[target] never stay there, it's just gone all the time: local require = require(script.Parent.loader).load(script)
local ActionPipe = require("ActionPipe")
local SharedAttackValues = require("SharedAttackValues")
local Promise = require("Promise")
local Players = game:GetService("Players")
local remote = game:GetService("ReplicatedStorage"):WaitForChild("CombatEvent")
local function GetTouchingParts(part)
local connection = part.Touched:Connect(function() end)
local results = part:GetTouchingParts()
connection:Disconnect()
return results
end
local function hitbox(size, cframe, ignore, char)
if(not workspace.Fx) then
local fx = Instance.new("Folder", workspace)
fx.Name = "Fx"
end
local hb = Instance.new("Part", workspace.Fx)
hb.Anchored = true
hb.CanCollide = false
hb.Transparency = .6
hb.Size = size
hb.Name = "Hitbox"
hb.Material = Enum.Material.ForceField
hb.CFrame = cframe
hb.CanQuery = false
local connection
connection = hb.Touched:Connect(function()
connection:Disconnect()
end)
local lastTarget
for i,v in pairs(hb:GetTouchingParts()) do
if v.Parent:FindFirstChild("Humanoid") and table.find(ignore, v.Parent) == nil then
if lastTarget then
if(lastTarget.Position - char.PrimaryPart.Position).Magnitude > (v.Position - char.PrimaryPart.Position).Magnitude then
lastTarget = v.Parent.PrimaryPart
end
else
lastTarget = v.Parent.PrimaryPart
end
end
end
hb:Destroy()
if lastTarget then
return lastTarget
else
return nil
end
end
return {
args = {
name = "AttackAction";
},
execute = function()
remote.OnServerEvent:Connect(function(player, data)
if SharedAttackValues.isTargetAttacked(data.Character) and tick() - SharedAttackValues.returnTick(data.Character) < 0.5 then
return
elseif SharedAttackValues.isTargetAttacked(data.Character) then
SharedAttackValues.setValue(data.Character, nil)
end
if(SharedAttackValues.isBeingAttacked[data.Character]) then
return
end
local actionPipe = ActionPipe.new()
local bodyVelocity = Instance.new("BodyVelocity", data.Character.PrimaryPart)
bodyVelocity.Velocity = data.Character.PrimaryPart.CFrame.LookVector * 25
bodyVelocity.MaxForce = Vector3.new(99999, 99999, 99999)
bodyVelocity.Name = "Knockback"
game.Debris:AddItem(bodyVelocity, .2)
local hitTarget = hitbox(Vector3.new(6, 6, 6), data.Character.PrimaryPart.CFrame * CFrame.new(0,0,-3), {data.Character}, data.Character)
if(hitTarget == nil) then
return
end
if(Players:GetPlayerFromCharacter(hitTarget.Parent) ~= nil) then
Players:GetPlayerFromCharacter(hitTarget.Parent):FindFirstChild("LastTarget").Value = tostring(data.Character)
end
SharedAttackValues.setValue(hitTarget.Parent, tick())
hitTarget.Parent.Humanoid.WalkSpeed = 0
SharedAttackValues.isBeingAttacked[hitTarget.Parent] = true
print(tostring(hitTarget.Parent) .. " is being attacked")
Promise.delay(.5, function()
if(SharedAttackValues.returnTick(hitTarget.Parent) ~= nil) then
print(tick() - SharedAttackValues.returnTick(hitTarget.Parent))
if tick() - SharedAttackValues.returnTick(hitTarget.Parent) > 0.5 then
print(tostring(hitTarget.Parent) .. " is no longer being attacked")
SharedAttackValues.isBeingAttacked[hitTarget.Parent] = false
end
end
end)
if data.Action == "m1" then
if(data.Combo == 5) then
hitTarget.Parent.Humanoid:TakeDamage(12)
else
hitTarget.Parent.Humanoid:TakeDamage(8)
end
end
if(data.Combo == 5) then
actionPipe.executeClientAction(player, "DragAction", data)
local bodyVelocity = Instance.new("BodyVelocity", hitTarget)
bodyVelocity.Velocity = data.Character.PrimaryPart.CFrame.LookVector * 75
bodyVelocity.MaxForce = Vector3.new(99999, 99999, 99999)
bodyVelocity.Name = "Knockback"
game.Debris:AddItem(bodyVelocity, .2)
else
local bodyVelocity = Instance.new("BodyVelocity", hitTarget)
bodyVelocity.Velocity = data.Character.PrimaryPart.CFrame.LookVector * 25
bodyVelocity.MaxForce = Vector3.new(99999, 99999, 99999)
bodyVelocity.Name = "Knockback"
game.Debris:AddItem(bodyVelocity, .2)
end
task.wait(1)
hitTarget.Parent.Humanoid.WalkSpeed = 10
end)
end
}
|
1d40f3616c50e08c54c28088e9340d35
|
{
"intermediate": 0.40102794766426086,
"beginner": 0.43011727929115295,
"expert": 0.168854758143425
}
|
44,427
|
from ray import tune
# Define a dictionary to represent the search space for hyperparameters
config = {
"feature_size": tune.uniform(128, 512), # Tune feature size between 128 and 512
"num_layers": tune.randint(1, 4), # Tune number of Transformer layers (1 to 4)
"dropout": tune.uniform(0.05, 0.2), # Tune dropout rate between 0.05 and 0.2
"lr": tune.loguniform(1e-4, 1e-2), # Tune learning rate using log-uniform sampling
}
class TransAmTrainable(tune.Trainable):
def setup(self, config):
self.model = TransAm(feature_size=config["feature_size"],
num_layers=config["num_layers"],
dropout=config["dropout"])
self.model.to(device)
self.criterion = nn.MSELoss()
self.optimizer = torch.optim.SGD(self.model.parameters(), lr=config["lr"])
def train_batch(self, train_data):
data, targets = get_batch(train_data) # Assuming your `get_batch` function exists
optimizer.zero_grad()
output, _ = self.model(data)
loss = self.criterion(output, targets)
loss.backward()
optimizer.step()
return loss.item() # Return the training loss
def validation_loss(self, val_data):
self.model.eval() # Set the model to evaluation mode
with torch.no_grad():
val_loss = 0.0
for data, target in val_data: # Iterate through validation data
output, _ = self.model(data)
val_loss += self.criterion(output, target).item()
val_loss /= len(val_data) # Average validation loss
return val_loss # Return the validation loss
def train(self, train_data, val_data):
# Train the model for a single epoch
train_loss = self.train_batch(train_data)
val_loss = self.validation_loss(val_data)
# Update Weights & Biases with training and validation loss
wandb.log({"train_loss": train_loss, "val_loss": val_loss})
self.optimizer.step()
return {"loss": val_loss} # Return the validation loss for Ray Tune
from ray import tune
from wandb import init
import os
from ray.tune.suggest.hyperopt import HyperOptSearch
# Initialize Weights & Biases (replace with your project name)
init(project="Transformer Time Series Prediction")
def train_fn(config, checkpoint_dir=None):
# Load model from checkpoint if provided (for resuming training)
model = TransAmTrainable(config) # Pass the config to the model
if checkpoint_dir:
model.load_checkpoint(checkpoint_dir)
train_data, val_data = get_data() # Load your training and validation data
results = model.train(train_data, val_data)
# Manually report the best checkpoint at the end of training
if checkpoint_dir:
model.save_checkpoint(checkpoint_dir)
tune.report(loss=results["loss"], checkpoint=checkpoint_dir)
else:
tune.report(loss=results["loss"])
# Launch the Ray Tune experiment with PBT (Population Based Training)
analysis = tune.run(
train_fn,
config=config, # Pass the configuration space
metric="loss", # Minimize validation loss
mode="min",
num_samples=16, # Number of hyperparameter configurations to try
# search_alg=tune.suggest.SigOptSearch(
# metric="loss", # Optimize for validation loss
# mode="min"
# ),
search_alg=HyperOptSearch(
metric="loss", # Optimize for validation loss
mode="min"
),
scheduler=tune.schedulers.PopulationBasedTraining(
time_attr="training_iteration",
perturbation_interval=5,
hyperparam_mutations={
"lr": tune.uniform(1e-4, 1e-2), # Learning rate between 1e-4 and 1e-2
"optimizer": tune.choice(["adam", "sgd"]) # Choose between Adam and SGD
}
),
# Track experiment results in Weights & Biases
name="TransAm_Hyperparameter_Tuning",
local_dir="./ray_results",
)
# Print the best trial results
best_trial = analysis.best_trial
print("Best trial config:", best_trial.config)
print("Best trial final validation loss:", best_trial.last_result["loss"])
can you fix the above code
|
be58d1596da35687efb93ed1a41fb18c
|
{
"intermediate": 0.3662126958370209,
"beginner": 0.3732984960079193,
"expert": 0.26048874855041504
}
|
44,428
|
how do i make a button in javascript
|
8eb85e6598344973cb592bce4fa4545e
|
{
"intermediate": 0.4229671061038971,
"beginner": 0.27956423163414,
"expert": 0.2974686622619629
}
|
44,429
|
Hi!
|
bdc15e8d2b8877df7bc773a758519bca
|
{
"intermediate": 0.3230988085269928,
"beginner": 0.2665199935436249,
"expert": 0.4103812277317047
}
|
44,430
|
ha habido un error de conexión entre nosotros. te pongo al día de nuestra última conversación:
YO: dónde debería implementar el comando ‘_move_to_cache’?:
from future import annotations
import shutil
import os
def _move_to_cache(file_path, cache_dir):
# Comprueba si el archivo ya está en el directorio deseado
if os.path.commonpath([file_path, cache_dir]) == cache_dir:
return file_path
else:
# Intenta copiar el archivo al cache_dir en lugar de moverlo
try:
file_name = os.path.basename(file_path)
new_file_path = os.path.join(cache_dir, file_name)
shutil.copy(file_path, new_file_path)
return new_file_path
except Exception as e:
# Manejar la excepción según sea necesario
print(f"No se pudo copiar el archivo a la caché debido a: {e}“)
# Dependiendo de tu caso, podrías querer devolver la ruta original
# o manejar de otra manera este fallo
return file_path
import base64
import hashlib
import json
import logging
import os
import shutil
import subprocess
import tempfile
import warnings
from io import BytesIO
from pathlib import Path
from typing import TYPE_CHECKING, Any
import httpx
import numpy as np
from gradio_client import utils as client_utils
from PIL import Image, ImageOps, PngImagePlugin
from gradio import utils, wasm_utils
from gradio.data_classes import FileData, GradioModel, GradioRootModel
from gradio.utils import abspath, get_upload_folder, is_in_or_equal
with warnings.catch_warnings():
warnings.simplefilter(“ignore”) # Ignore pydub warning if ffmpeg is not installed
from pydub import AudioSegment
log = logging.getLogger(name)
if TYPE_CHECKING:
from gradio.blocks import Block
#########################
# GENERAL
#########################
def to_binary(x: str | dict) -> bytes:
“”“Converts a base64 string or dictionary to a binary string that can be sent in a POST.””“
if isinstance(x, dict):
if x.get(“data”):
base64str = x[“data”]
else:
base64str = client_utils.encode_url_or_file_to_base64(x[“path”])
else:
base64str = x
return base64.b64decode(extract_base64_data(base64str))
def extract_base64_data(x: str) -> str:
“”“Just extracts the base64 data from a general base64 string.””“
return x.rsplit(”,“, 1)[-1]
#########################
# IMAGE PRE-PROCESSING
#########################
def encode_plot_to_base64(plt, format: str = “png”):
fmt = format or “png”
with BytesIO() as output_bytes:
plt.savefig(output_bytes, format=fmt)
bytes_data = output_bytes.getvalue()
base64_str = str(base64.b64encode(bytes_data), “utf-8”)
return output_base64(base64_str, fmt)
def get_pil_exif_bytes(pil_image):
if “exif” in pil_image.info:
return pil_image.info[“exif”]
def get_pil_metadata(pil_image):
# Copy any text-only metadata
metadata = PngImagePlugin.PngInfo()
for key, value in pil_image.info.items():
if isinstance(key, str) and isinstance(value, str):
metadata.add_text(key, value)
return metadata
def encode_pil_to_bytes(pil_image, format=“png”):
with BytesIO() as output_bytes:
if format == “png”:
params = {“pnginfo”: get_pil_metadata(pil_image)}
else:
exif = get_pil_exif_bytes(pil_image)
params = {“exif”: exif} if exif else {}
pil_image.save(output_bytes, format, params)
return output_bytes.getvalue()
def encode_pil_to_base64(pil_image, format=“png”):
bytes_data = encode_pil_to_bytes(pil_image, format)
base64_str = str(base64.b64encode(bytes_data), “utf-8”)
return output_base64(base64_str, format)
def encode_array_to_base64(image_array, format=“png”):
with BytesIO() as output_bytes:
pil_image = Image.fromarray(_convert(image_array, np.uint8, force_copy=False))
pil_image.save(output_bytes, format)
bytes_data = output_bytes.getvalue()
base64_str = str(base64.b64encode(bytes_data), “utf-8”)
return output_base64(base64_str, format)
def output_base64(data, format=None) -> str:
return f"data:image/{format or ‘png’};base64,{data}“
def hash_file(file_path: str | Path, chunk_num_blocks: int = 128) -> str:
sha1 = hashlib.sha1()
with open(file_path, “rb”) as f:
for chunk in iter(lambda: f.read(chunk_num_blocks * sha1.block_size), b”“):
sha1.update(chunk)
return sha1.hexdigest()
def hash_url(url: str) -> str:
sha1 = hashlib.sha1()
sha1.update(url.encode(“utf-8”))
return sha1.hexdigest()
def hash_bytes(bytes: bytes):
sha1 = hashlib.sha1()
sha1.update(bytes)
return sha1.hexdigest()
def hash_base64(base64_encoding: str, chunk_num_blocks: int = 128) -> str:
sha1 = hashlib.sha1()
for i in range(0, len(base64_encoding), chunk_num_blocks * sha1.block_size):
data = base64_encoding[i : i + chunk_num_blocks * sha1.block_size]
sha1.update(data.encode(“utf-8”))
return sha1.hexdigest()
def save_pil_to_cache(
img: Image.Image,
cache_dir: str,
name: str = “image”,
format: str = “png”,
) -> str:
bytes_data = encode_pil_to_bytes(img, format)
temp_dir = Path(cache_dir) / hash_bytes(bytes_data)
temp_dir.mkdir(exist_ok=True, parents=True)
filename = str((temp_dir / f”{name}.{format}“).resolve())
(temp_dir / f”{name}.{format}“).resolve().write_bytes(bytes_data)
return filename
def save_img_array_to_cache(
arr: np.ndarray, cache_dir: str, format: str = “png”
) -> str:
pil_image = Image.fromarray(_convert(arr, np.uint8, force_copy=False))
return save_pil_to_cache(pil_image, cache_dir, format=format)
def save_audio_to_cache(
data: np.ndarray, sample_rate: int, format: str, cache_dir: str
) -> str:
temp_dir = Path(cache_dir) / hash_bytes(data.tobytes())
temp_dir.mkdir(exist_ok=True, parents=True)
filename = str((temp_dir / f"audio.{format}”).resolve())
audio_to_file(sample_rate, data, filename, format=format)
return filename
def save_bytes_to_cache(data: bytes, file_name: str, cache_dir: str) -> str:
path = Path(cache_dir) / hash_bytes(data)
path.mkdir(exist_ok=True, parents=True)
path = path / Path(file_name).name
path.write_bytes(data)
return str(path.resolve())
def save_file_to_cache(file_path: str | Path, cache_dir: str) -> str:
“”“Returns a temporary file path for a copy of the given file path if it does
not already exist. Otherwise returns the path to the existing temp file.”“”
temp_dir = hash_file(file_path)
temp_dir = Path(cache_dir) / temp_dir
temp_dir.mkdir(exist_ok=True, parents=True)
name = client_utils.strip_invalid_filename_characters(Path(file_path).name)
full_temp_file_path = str(abspath(temp_dir / name))
if not Path(full_temp_file_path).exists():
shutil.copy2(file_path, full_temp_file_path)
return full_temp_file_path
def save_url_to_cache(url: str, cache_dir: str) -> str:
“”“Downloads a file and makes a temporary file path for a copy if does not already
exist. Otherwise returns the path to the existing temp file.”“”
temp_dir = hash_url(url)
temp_dir = Path(cache_dir) / temp_dir
temp_dir.mkdir(exist_ok=True, parents=True)
name = client_utils.strip_invalid_filename_characters(Path(url).name)
full_temp_file_path = str(abspath(temp_dir / name))
if not Path(full_temp_file_path).exists():
with httpx.stream(“GET”, url, follow_redirects=True) as r, open(
full_temp_file_path, “wb”
) as f:
for chunk in r.iter_raw():
f.write(chunk)
return full_temp_file_path
def save_base64_to_cache(
base64_encoding: str, cache_dir: str, file_name: str | None = None
) -> str:
“”“Converts a base64 encoding to a file and returns the path to the file if
the file doesn’t already exist. Otherwise returns the path to the existing file.
“””
temp_dir = hash_base64(base64_encoding)
temp_dir = Path(cache_dir) / temp_dir
temp_dir.mkdir(exist_ok=True, parents=True)
guess_extension = client_utils.get_extension(base64_encoding)
if file_name:
file_name = client_utils.strip_invalid_filename_characters(file_name)
elif guess_extension:
file_name = f"file.{guess_extension}“
else:
file_name = “file”
full_temp_file_path = str(abspath(temp_dir / file_name)) # type: ignore
if not Path(full_temp_file_path).exists():
data, _ = client_utils.decode_base64_to_binary(base64_encoding)
with open(full_temp_file_path, “wb”) as fb:
fb.write(data)
return full_temp_file_path
def move_resource_to_block_cache(
url_or_file_path: str | Path | None, block: Block
) -> str | None:
“”“This method has been replaced by Block.move_resource_to_block_cache(), but is
left here for backwards compatibility for any custom components created in Gradio 4.2.0 or earlier.
“””
return block.move_resource_to_block_cache(url_or_file_path)
def move_files_to_cache(
data: Any,
block: Block,
postprocess: bool = False,
check_in_upload_folder=False,
keep_in_cache=False,
) -> dict:
“”“Move any files in data to cache and (optionally), adds URL prefixes (/file=…) needed to access the cached file.
Also handles the case where the file is on an external Gradio app (/proxy=…).
Runs after .postprocess() and before .preprocess().
Args:
data: The input or output data for a component. Can be a dictionary or a dataclass
block: The component whose data is being processed
postprocess: Whether its running from postprocessing
check_in_upload_folder: If True, instead of moving the file to cache, checks if the file is in already in cache (exception if not).
keep_in_cache: If True, the file will not be deleted from cache when the server is shut down.
“””
def _move_to_cache(d: dict):
payload = FileData(d)
# If the gradio app developer is returning a URL from
# postprocess, it means the component can display a URL
# without it being served from the gradio server
# This makes it so that the URL is not downloaded and speeds up event processing
if payload.url and postprocess and client_utils.is_http_url_like(payload.url):
payload.path = payload.url
elif utils.is_static_file(payload):
pass
elif not block.proxy_url:
# If the file is on a remote server, do not move it to cache.
if check_in_upload_folder and not client_utils.is_http_url_like(
payload.path
):
path = os.path.abspath(payload.path)
if not is_in_or_equal(path, get_upload_folder()):
raise ValueError(
f"File {path} is not in the upload folder and cannot be accessed.“
)
temp_file_path = block.move_resource_to_block_cache(payload.path)
if temp_file_path is None:
raise ValueError(“Did not determine a file path for the resource.”)
payload.path = temp_file_path
if keep_in_cache:
block.keep_in_cache.add(payload.path)
url_prefix = “/stream/” if payload.is_stream else “/file=”
if block.proxy_url:
proxy_url = block.proxy_url.rstrip(”/“)
url = f”/proxy={proxy_url}{url_prefix}{payload.path}“
elif client_utils.is_http_url_like(payload.path) or payload.path.startswith(
f”{url_prefix}“
):
url = payload.path
else:
url = f”{url_prefix}{payload.path}”
payload.url = url
return payload.model_dump()
if isinstance(data, (GradioRootModel, GradioModel)):
data = data.model_dump()
return client_utils.traverse(data, _move_to_cache, client_utils.is_file_obj)
def add_root_url(data: dict | list, root_url: str, previous_root_url: str | None):
def _add_root_url(file_dict: dict):
if previous_root_url and file_dict[“url”].startswith(previous_root_url):
file_dict[“url”] = file_dict[“url”][len(previous_root_url) :]
elif client_utils.is_http_url_like(file_dict[“url”]):
return file_dict
file_dict[“url”] = f’{root_url}{file_dict[“url”]}'
return file_dict
return client_utils.traverse(data, add_root_url, client_utils.is_file_obj_with_url)
def resize_and_crop(img, size, crop_type=“center”):
“”“
Resize and crop an image to fit the specified size.
args:
size: (width, height) tuple. Pass None for either width or height
to only crop and resize the other.
crop_type: can be ‘top’, ‘middle’ or ‘bottom’, depending on this
value, the image will cropped getting the ‘top/left’, ‘middle’ or
‘bottom/right’ of the image to fit the size.
raises:
ValueError: if an invalid crop_type is provided.
“””
if crop_type == “top”:
center = (0, 0)
elif crop_type == “center”:
center = (0.5, 0.5)
else:
raise ValueError
resize = list(size)
if size[0] is None:
resize[0] = img.size[0]
if size[1] is None:
resize[1] = img.size[1]
return ImageOps.fit(img, resize, centering=center) # type: ignore
##################
# Audio
##################
def audio_from_file(filename, crop_min=0, crop_max=100):
try:
audio = AudioSegment.from_file(filename)
except FileNotFoundError as e:
isfile = Path(filename).is_file()
msg = (
f"Cannot load audio from file: {‘ffprobe’ if isfile else filename} not found.“
+ " Please install ffmpeg in your system to use non-WAV audio file formats”
" and make sure ffprobe is in your PATH."
if isfile
else “”
)
raise RuntimeError(msg) from e
if crop_min != 0 or crop_max != 100:
audio_start = len(audio) * crop_min / 100
audio_end = len(audio) * crop_max / 100
audio = audio[audio_start:audio_end]
data = np.array(audio.get_array_of_samples())
if audio.channels > 1:
data = data.reshape(-1, audio.channels)
return audio.frame_rate, data
def audio_to_file(sample_rate, data, filename, format=“wav”):
if format == “wav”:
data = convert_to_16_bit_wav(data)
audio = AudioSegment(
data.tobytes(),
frame_rate=sample_rate,
sample_width=data.dtype.itemsize,
channels=(1 if len(data.shape) == 1 else data.shape[1]),
)
file = audio.export(filename, format=format)
file.close() # type: ignore
def convert_to_16_bit_wav(data):
# Based on: https://docs.scipy.org/doc/scipy/reference/generated/scipy.io.wavfile.write.html
warning = “Trying to convert audio automatically from {} to 16-bit int format.”
if data.dtype in [np.float64, np.float32, np.float16]:
warnings.warn(warning.format(data.dtype))
data = data / np.abs(data).max()
data = data * 32767
data = data.astype(np.int16)
elif data.dtype == np.int32:
warnings.warn(warning.format(data.dtype))
data = data / 65536
data = data.astype(np.int16)
elif data.dtype == np.int16:
pass
elif data.dtype == np.uint16:
warnings.warn(warning.format(data.dtype))
data = data - 32768
data = data.astype(np.int16)
elif data.dtype == np.uint8:
warnings.warn(warning.format(data.dtype))
data = data * 257 - 32768
data = data.astype(np.int16)
elif data.dtype == np.int8:
warnings.warn(warning.format(data.dtype))
data = data * 256
data = data.astype(np.int16)
else:
raise ValueError(
“Audio data cannot be converted automatically from “
f”{data.dtype} to 16-bit int format.”
)
return data
##################
# OUTPUT
##################
def convert(image, dtype, force_copy=False, uniform=False):
“”“
Adapted from: https://github.com/scikit-image/scikit-image/blob/main/skimage/util/dtype.py#L510-L531
Convert an image to the requested data-type.
Warnings are issued in case of precision loss, or when negative values
are clipped during conversion to unsigned integer types (sign loss).
Floating point values are expected to be normalized and will be clipped
to the range [0.0, 1.0] or [-1.0, 1.0] when converting to unsigned or
signed integers respectively.
Numbers are not shifted to the negative side when converting from
unsigned to signed integer types. Negative values will be clipped when
converting to unsigned integers.
Parameters
----------
image : ndarray
Input image.
dtype : dtype
Target data-type.
force_copy : bool, optional
Force a copy of the data, irrespective of its current dtype.
uniform : bool, optional
Uniformly quantize the floating point range to the integer range.
By default (uniform=False) floating point values are scaled and
rounded to the nearest integers, which minimizes back and forth
conversion errors.
… versionchanged :: 0.15
_convert no longer warns about possible precision or sign
information loss. See discussions on these warnings at:
https://github.com/scikit-image/scikit-image/issues/2602
https://github.com/scikit-image/scikit-image/issues/543#issuecomment-208202228
https://github.com/scikit-image/scikit-image/pull/3575
References
----------
… [1] DirectX data conversion rules.
https://msdn.microsoft.com/en-us/library/windows/desktop/dd607323(v=vs.85).aspx
… [2] Data Conversions. In “OpenGL ES 2.0 Specification v2.0.25”,
pp 7-8. Khronos Group, 2010.
… [3] Proper treatment of pixels as integers. A.W. Paeth.
In “Graphics Gems I”, pp 249-256. Morgan Kaufmann, 1990.
… [4] Dirty Pixels. J. Blinn. In “Jim Blinn’s corner: Dirty Pixels”,
pp 47-57. Morgan Kaufmann, 1998.
“””
dtype_range = {
bool: (False, True),
np.bool: (False, True),
np.bool8: (False, True), # type: ignore
float: (-1, 1),
np.float: (-1, 1),
np.float16: (-1, 1),
np.float32: (-1, 1),
np.float64: (-1, 1),
}
def _dtype_itemsize(itemsize, *dtypes):
“”“Return first of dtypes with itemsize greater than itemsize
Parameters
----------
itemsize: int
The data type object element size.
Other Parameters
----------------
*dtypes:
Any Object accepted by np.dtype to be converted to a data
type object
Returns
-------
dtype: data type object
First of dtypes with itemsize greater than itemsize.
“””
return next(dt for dt in dtypes if np.dtype(dt).itemsize >= itemsize)
def _dtype_bits(kind, bits, itemsize=1):
“”“Return dtype of kind that can store a bits wide unsigned int
Parameters:
kind: str
Data type kind.
bits: int
Desired number of bits.
itemsize: int
The data type object element size.
Returns
-------
dtype: data type object
Data type of kind that can store a bits wide unsigned int
“””
s = next(
i
for i in (itemsize,) + (2, 4, 8)
if bits < (i * 8) or (bits == (i * 8) and kind == “u”)
)
return np.dtype(kind + str(s))
def _scale(a, n, m, copy=True):
“”“Scale an array of unsigned/positive integers from n to m bits.
Numbers can be represented exactly only if m is a multiple of n.
Parameters
----------
a : ndarray
Input image array.
n : int
Number of bits currently used to encode the values in a.
m : int
Desired number of bits to encode the values in out.
copy : bool, optional
If True, allocates and returns new array. Otherwise, modifies
a in place.
Returns
-------
out : array
Output image array. Has the same kind as a.
“””
kind = a.dtype.kind
if n > m and a.max() < 2m:
return a.astype(_dtype_bits(kind, m))
elif n == m:
return a.copy() if copy else a
elif n > m:
# downscale with precision loss
if copy:
b = np.empty(a.shape, _dtype_bits(kind, m))
np.floor_divide(a, 2 ** (n - m), out=b, dtype=a.dtype, casting=“unsafe”)
return b
else:
a //= 2 ** (n - m)
return a
elif m % n == 0:
# exact upscale to a multiple of n bits
if copy:
b = np.empty(a.shape, _dtype_bits(kind, m))
np.multiply(a, (2m - 1) // (2n - 1), out=b, dtype=b.dtype)
return b
else:
a = a.astype(_dtype_bits(kind, m, a.dtype.itemsize), copy=False)
a *= (2m - 1) // (2n - 1)
return a
else:
# upscale to a multiple of n bits,
# then downscale with precision loss
o = (m // n + 1) * n
if copy:
b = np.empty(a.shape, _dtype_bits(kind, o))
np.multiply(a, (2o - 1) // (2n - 1), out=b, dtype=b.dtype)
b //= 2 ** (o - m)
return b
else:
a = a.astype(_dtype_bits(kind, o, a.dtype.itemsize), copy=False)
a *= (2o - 1) // (2**n - 1)
a //= 2 ** (o - m)
return a
image = np.asarray(image)
dtypeobj_in = image.dtype
dtypeobj_out = np.dtype(“float64”) if dtype is np.floating else np.dtype(dtype)
dtype_in = dtypeobj_in.type
dtype_out = dtypeobj_out.type
kind_in = dtypeobj_in.kind
kind_out = dtypeobj_out.kind
itemsize_in = dtypeobj_in.itemsize
itemsize_out = dtypeobj_out.itemsize
# Below, we do an issubdtype check. Its purpose is to find out
# whether we can get away without doing any image conversion. This happens
# when:
#
# - the output and input dtypes are the same or
# - when the output is specified as a type, and the input dtype
# is a subclass of that type (e.g. np.floating will allow
# float32 and float64 arrays through)
if np.issubdtype(dtype_in, np.obj2sctype(dtype)):
if force_copy:
image = image.copy()
return image
if kind_in in “ui”:
imin_in = np.iinfo(dtype_in).min
imax_in = np.iinfo(dtype_in).max
if kind_out in “ui”:
imin_out = np.iinfo(dtype_out).min # type: ignore
imax_out = np.iinfo(dtype_out).max # type: ignore
# any -> binary
if kind_out == “b”:
return image > dtype_in(dtype_range[dtype_in][1] / 2)
# binary -> any
if kind_in == “b”:
result = image.astype(dtype_out)
if kind_out != “f”:
result *= dtype_out(dtype_range[dtype_out][1])
return result
# float -> any
if kind_in == “f”:
if kind_out == “f”:
# float -> float
return image.astype(dtype_out)
if np.min(image) < -1.0 or np.max(image) > 1.0:
raise ValueError(“Images of type float must be between -1 and 1.”)
# floating point -> integer
# use float type that can represent output integer type
computation_type = _dtype_itemsize(
itemsize_out, dtype_in, np.float32, np.float64
)
if not uniform:
if kind_out == “u”:
image_out = np.multiply(image, imax_out, dtype=computation_type) # type: ignore
else:
image_out = np.multiply(
image,
(imax_out - imin_out) / 2, # type: ignore
dtype=computation_type,
)
image_out -= 1.0 / 2.0
np.rint(image_out, out=image_out)
np.clip(image_out, imin_out, imax_out, out=image_out) # type: ignore
elif kind_out == “u”:
image_out = np.multiply(image, imax_out + 1, dtype=computation_type) # type: ignore
np.clip(image_out, 0, imax_out, out=image_out) # type: ignore
else:
image_out = np.multiply(
image,
(imax_out - imin_out + 1.0) / 2.0, # type: ignore
dtype=computation_type,
)
np.floor(image_out, out=image_out)
np.clip(image_out, imin_out, imax_out, out=image_out) # type: ignore
return image_out.astype(dtype_out)
# signed/unsigned int -> float
if kind_out == “f”:
# use float type that can exactly represent input integers
computation_type = _dtype_itemsize(
itemsize_in, dtype_out, np.float32, np.float64
)
if kind_in == “u”:
# using np.divide or np.multiply doesn’t copy the data
# until the computation time
image = np.multiply(image, 1.0 / imax_in, dtype=computation_type) # type: ignore
# DirectX uses this conversion also for signed ints
# if imin_in:
# np.maximum(image, -1.0, out=image)
else:
image = np.add(image, 0.5, dtype=computation_type)
image *= 2 / (imax_in - imin_in) # type: ignore
return np.asarray(image, dtype_out)
# unsigned int -> signed/unsigned int
if kind_in == “u”:
if kind_out == “i”:
# unsigned int -> signed int
image = _scale(image, 8 * itemsize_in, 8 * itemsize_out - 1)
return image.view(dtype_out)
else:
# unsigned int -> unsigned int
return _scale(image, 8 * itemsize_in, 8 * itemsize_out)
# signed int -> unsigned int
if kind_out == “u”:
image = scale(image, 8 * itemsize_in - 1, 8 * itemsize_out)
result = np.empty(image.shape, dtype_out)
np.maximum(image, 0, out=result, dtype=image.dtype, casting=“unsafe”)
return result
# signed int -> signed int
if itemsize_in > itemsize_out:
return scale(image, 8 * itemsize_in - 1, 8 * itemsize_out - 1)
image = image.astype(dtype_bits(“i”, itemsize_out * 8))
image -= imin_in # type: ignore
image = scale(image, 8 * itemsize_in, 8 * itemsize_out, copy=False)
image += imin_out # type: ignore
return image.astype(dtype_out)
def ffmpeg_installed() -> bool:
if wasm_utils.IS_WASM:
# TODO: Support ffmpeg in WASM
return False
return shutil.which(“ffmpeg”) is not None
def video_is_playable(video_filepath: str) -> bool:
“”“Determines if a video is playable in the browser.
A video is playable if it has a playable container and codec.
.mp4 -> h264
.webm -> vp9
.ogg -> theora
“””
from ffmpy import FFprobe, FFRuntimeError
try:
container = Path(video_filepath).suffix.lower()
probe = FFprobe(
global_options=”-show_format -show_streams -select_streams v -print_format json",
inputs={video_filepath: None},
)
output = probe.run(stderr=subprocess.PIPE, stdout=subprocess.PIPE)
output = json.loads(output[0])
video_codec = output[“streams”][0][“codec_name”]
return (container, video_codec) in [
(“.mp4”, “h264”),
(“.ogg”, “theora”),
(“.webm”, “vp9”),
]
# If anything goes wrong, assume the video can be played to not convert downstream
except (FFRuntimeError, IndexError, KeyError):
return True
def convert_video_to_playable_mp4(video_path: str) -> str:
“”“Convert the video to mp4. If something goes wrong return the original video.”“”
from ffmpy import FFmpeg, FFRuntimeError
try:
with tempfile.NamedTemporaryFile(delete=False) as tmp_file:
output_path = Path(video_path).with_suffix(“.mp4”)
shutil.copy2(video_path, tmp_file.name)
# ffmpeg will automatically use h264 codec (playable in browser) when converting to mp4
ff = FFmpeg(
inputs={str(tmp_file.name): None},
outputs={str(output_path): None},
global_options=“-y -loglevel quiet”,
)
ff.run()
except FFRuntimeError as e:
print(f"Error converting video to browser-playable format {str(e)}")
output_path = video_path
finally:
# Remove temp file
os.remove(tmp_file.name) # type: ignore
return str(output_path)
def get_video_length(video_path: str | Path):
if wasm_utils.IS_WASM:
raise wasm_utils.WasmUnsupportedError(
“Video duration is not supported in the Wasm mode.”
)
duration = subprocess.check_output(
[
“ffprobe”,
“-i”,
str(video_path),
“-show_entries”,
“format=duration”,
“-v”,
“quiet”,
“-of”,
“csv={}”.format(“p=0”),
]
)
duration_str = duration.decode(“utf-8”).strip()
duration_float = float(duration_str)
return duration_float
TÚ: El ejemplo de código que proporcionas es una mezcla de varias funcionalidades y utilidades relacionadas principalmente con el procesamiento de archivos, audio, imagen y video para su uso, posiblemente, en una aplicación web o un sistema que trabaja intensamente con contenido multimedia. La función move_to_cache(file_path, cache_dir) está diseñada para mover (o en tu caso, copiar) archivos a un directorio de caché especificado.
Para decidir en qué lugar deberías implementar el comando move_to_cache, es importante considerar el contexto de uso y el flujo de trabajo de la aplicación. Basándome en el código que proporcionas, el cual parece estar relacionado con la manipulación y la preparación de datos para su utilización o presentación, existen varios puntos donde podría ser relevante el uso de esta función:
1. Durante la carga de recursos: Cuando se cargan archivos (ej. imágenes, audio, video) en tu aplicación, puede ser deseable copiar estos archivos a un directorio de caché para un acceso más rápido en el futuro. Esto es especialmente útil si los archivos se van a procesar o convertir de alguna forma.
2. Después de procesar contenidos: Si tu aplicación realiza algún procesamiento en archivos, como conversión de formatos, redimensionamiento de imágenes, etc., podrías querer almacenar el resultado en caché para evitar tener que repetir el procesamiento.
3. Antes de servir archivos a los usuarios: Si estás sirviendo contenido estático o dinámico a los usuarios y este contenido cambia poco con el tiempo, implementar move_to_cache antes de la entrega podría ayudar a mejorar la eficiencia, reduciendo la carga en los servidores y acelerando la entrega de contenido.
Dentro del contexto del código que proporcionas, aquí hay algunas ideas más específicas:
- Después de generar o modificar imágenes (ver save_pil_to_cache, save_img_array_to_cache).
- Al guardar archivos de audio o video procesados (ver save_audio_to_cache).
- Tras completar la descarga y antes de la entrega de archivos externos (ver save_url_to_cache, save_file_to_cache).
- Antes de devolver los resultados de las funciones que procesan archivos base64 (ver save_base64_to_cache).
Por último, asegúrate de considerar el manejo de errores y la limpieza de la caché como parte de la implementación para evitar el crecimiento descontrolado del almacenamiento y otros posibles problemas.
Tras esta conversación, y el error de conexión, te indico que me interesaría saber en que lugar del código debo insertar el comando move_to_cache teniendo en cuenta que me interesa que sea respecto al punto ‘1. Durante la carga de recusrsos’ que me indicas anteriormente.
Para implementar el comando _move_to_cache durante la carga de recursos en tu aplicación, te sugiero que lo insertes en el punto donde se realiza la carga de los archivos que deseas copiar al directorio de caché. En el contexto del código que proporcionaste, esto podría ser en la función o método que se encarga de manejar la llegada de nuevos archivos o recursos a tu sistema.
Aquí tienes un ejemplo de cómo podrías integrar la función _move_to_cache durante la carga de recursos:
# Función que maneja la carga de un nuevo archivo
def handle_new_file(file_path, cache_dir):
# Realizar las operaciones necesarias antes de copiar el archivo al directorio de caché
# (por ejemplo, validación, procesamiento, etc.)
# Llamar a la función _move_to_cache para copiar el archivo al directorio de caché
cached_file_path = _move_to_cache(file_path, cache_dir)
# Continuar con el resto del procesamiento o almacenamiento del archivo si es necesario
return cached_file_path
# Lugar donde se invoca la función handle_new_file al cargar un nuevo archivo
new_file_path = “ruta/del/nuevo/archivo”
cache_directory = “directorio/de/cache”
resulting_cached_file = handle_new_file(new_file_path, cache_directory)
En este ejemplo simplificado, la función handle_new_file se encarga de realizar las operaciones necesarias antes de copiar el archivo al directorio de caché, y luego invoca la función _move_to_cache para llevar a cabo la copia. Asegúrate de ajustar este código a la estructura y flujo de tu aplicación para que se integre de manera coherente con el resto de tu lógica.
Al incorporar _move_to_cache de esta manera durante la carga de recursos, estarás asegurándote de que los archivos se copien al directorio de caché en el momento adecuado, optimizando el acceso futuro a estos recursos. ¡Espero que esta información te sea útil y te ayude a implementar de manera efectiva esta funcionalidad en tu aplicación! Si tienes alguna otra pregunta o necesitas más clarificaciones, no dudes en decírmelo.
_____________
quiero que implementes el comando directamente en el código, sin ejemplos ni explicaciones, tal y como debe ir; y quiero que me muestres el cambio y 10 líneas antes y 10 líneas después del lugar preciso del este.
|
a0afdc9e08fa734cac5a3383df681c7d
|
{
"intermediate": 0.4470202922821045,
"beginner": 0.45251667499542236,
"expert": 0.10046305507421494
}
|
44,431
|
ha habido un error de conexión entre nosotros. te pongo al día de nuestra última conversación:
YO: dónde debería implementar el comando ‘_move_to_cache’?:
from future import annotations
import shutil
import os
def _move_to_cache(file_path, cache_dir):
# Comprueba si el archivo ya está en el directorio deseado
if os.path.commonpath([file_path, cache_dir]) == cache_dir:
return file_path
else:
# Intenta copiar el archivo al cache_dir en lugar de moverlo
try:
file_name = os.path.basename(file_path)
new_file_path = os.path.join(cache_dir, file_name)
shutil.copy(file_path, new_file_path)
return new_file_path
except Exception as e:
# Manejar la excepción según sea necesario
print(f"No se pudo copiar el archivo a la caché debido a: {e}“)
# Dependiendo de tu caso, podrías querer devolver la ruta original
# o manejar de otra manera este fallo
return file_path
import base64
import hashlib
import json
import logging
import os
import shutil
import subprocess
import tempfile
import warnings
from io import BytesIO
from pathlib import Path
from typing import TYPE_CHECKING, Any
import httpx
import numpy as np
from gradio_client import utils as client_utils
from PIL import Image, ImageOps, PngImagePlugin
from gradio import utils, wasm_utils
from gradio.data_classes import FileData, GradioModel, GradioRootModel
from gradio.utils import abspath, get_upload_folder, is_in_or_equal
with warnings.catch_warnings():
warnings.simplefilter(“ignore”) # Ignore pydub warning if ffmpeg is not installed
from pydub import AudioSegment
log = logging.getLogger(name)
if TYPE_CHECKING:
from gradio.blocks import Block
#########################
# GENERAL
#########################
def to_binary(x: str | dict) -> bytes:
“”“Converts a base64 string or dictionary to a binary string that can be sent in a POST.””“
if isinstance(x, dict):
if x.get(“data”):
base64str = x[“data”]
else:
base64str = client_utils.encode_url_or_file_to_base64(x[“path”])
else:
base64str = x
return base64.b64decode(extract_base64_data(base64str))
def extract_base64_data(x: str) -> str:
“”“Just extracts the base64 data from a general base64 string.””“
return x.rsplit(”,“, 1)[-1]
#########################
# IMAGE PRE-PROCESSING
#########################
def encode_plot_to_base64(plt, format: str = “png”):
fmt = format or “png”
with BytesIO() as output_bytes:
plt.savefig(output_bytes, format=fmt)
bytes_data = output_bytes.getvalue()
base64_str = str(base64.b64encode(bytes_data), “utf-8”)
return output_base64(base64_str, fmt)
def get_pil_exif_bytes(pil_image):
if “exif” in pil_image.info:
return pil_image.info[“exif”]
def get_pil_metadata(pil_image):
# Copy any text-only metadata
metadata = PngImagePlugin.PngInfo()
for key, value in pil_image.info.items():
if isinstance(key, str) and isinstance(value, str):
metadata.add_text(key, value)
return metadata
def encode_pil_to_bytes(pil_image, format=“png”):
with BytesIO() as output_bytes:
if format == “png”:
params = {“pnginfo”: get_pil_metadata(pil_image)}
else:
exif = get_pil_exif_bytes(pil_image)
params = {“exif”: exif} if exif else {}
pil_image.save(output_bytes, format, params)
return output_bytes.getvalue()
def encode_pil_to_base64(pil_image, format=“png”):
bytes_data = encode_pil_to_bytes(pil_image, format)
base64_str = str(base64.b64encode(bytes_data), “utf-8”)
return output_base64(base64_str, format)
def encode_array_to_base64(image_array, format=“png”):
with BytesIO() as output_bytes:
pil_image = Image.fromarray(_convert(image_array, np.uint8, force_copy=False))
pil_image.save(output_bytes, format)
bytes_data = output_bytes.getvalue()
base64_str = str(base64.b64encode(bytes_data), “utf-8”)
return output_base64(base64_str, format)
def output_base64(data, format=None) -> str:
return f"data:image/{format or ‘png’};base64,{data}“
def hash_file(file_path: str | Path, chunk_num_blocks: int = 128) -> str:
sha1 = hashlib.sha1()
with open(file_path, “rb”) as f:
for chunk in iter(lambda: f.read(chunk_num_blocks * sha1.block_size), b”“):
sha1.update(chunk)
return sha1.hexdigest()
def hash_url(url: str) -> str:
sha1 = hashlib.sha1()
sha1.update(url.encode(“utf-8”))
return sha1.hexdigest()
def hash_bytes(bytes: bytes):
sha1 = hashlib.sha1()
sha1.update(bytes)
return sha1.hexdigest()
def hash_base64(base64_encoding: str, chunk_num_blocks: int = 128) -> str:
sha1 = hashlib.sha1()
for i in range(0, len(base64_encoding), chunk_num_blocks * sha1.block_size):
data = base64_encoding[i : i + chunk_num_blocks * sha1.block_size]
sha1.update(data.encode(“utf-8”))
return sha1.hexdigest()
def save_pil_to_cache(
img: Image.Image,
cache_dir: str,
name: str = “image”,
format: str = “png”,
) -> str:
bytes_data = encode_pil_to_bytes(img, format)
temp_dir = Path(cache_dir) / hash_bytes(bytes_data)
temp_dir.mkdir(exist_ok=True, parents=True)
filename = str((temp_dir / f”{name}.{format}“).resolve())
(temp_dir / f”{name}.{format}“).resolve().write_bytes(bytes_data)
return filename
def save_img_array_to_cache(
arr: np.ndarray, cache_dir: str, format: str = “png”
) -> str:
pil_image = Image.fromarray(_convert(arr, np.uint8, force_copy=False))
return save_pil_to_cache(pil_image, cache_dir, format=format)
def save_audio_to_cache(
data: np.ndarray, sample_rate: int, format: str, cache_dir: str
) -> str:
temp_dir = Path(cache_dir) / hash_bytes(data.tobytes())
temp_dir.mkdir(exist_ok=True, parents=True)
filename = str((temp_dir / f"audio.{format}”).resolve())
audio_to_file(sample_rate, data, filename, format=format)
return filename
def save_bytes_to_cache(data: bytes, file_name: str, cache_dir: str) -> str:
path = Path(cache_dir) / hash_bytes(data)
path.mkdir(exist_ok=True, parents=True)
path = path / Path(file_name).name
path.write_bytes(data)
return str(path.resolve())
def save_file_to_cache(file_path: str | Path, cache_dir: str) -> str:
“”“Returns a temporary file path for a copy of the given file path if it does
not already exist. Otherwise returns the path to the existing temp file.”“”
temp_dir = hash_file(file_path)
temp_dir = Path(cache_dir) / temp_dir
temp_dir.mkdir(exist_ok=True, parents=True)
name = client_utils.strip_invalid_filename_characters(Path(file_path).name)
full_temp_file_path = str(abspath(temp_dir / name))
if not Path(full_temp_file_path).exists():
shutil.copy2(file_path, full_temp_file_path)
return full_temp_file_path
def save_url_to_cache(url: str, cache_dir: str) -> str:
“”“Downloads a file and makes a temporary file path for a copy if does not already
exist. Otherwise returns the path to the existing temp file.”“”
temp_dir = hash_url(url)
temp_dir = Path(cache_dir) / temp_dir
temp_dir.mkdir(exist_ok=True, parents=True)
name = client_utils.strip_invalid_filename_characters(Path(url).name)
full_temp_file_path = str(abspath(temp_dir / name))
if not Path(full_temp_file_path).exists():
with httpx.stream(“GET”, url, follow_redirects=True) as r, open(
full_temp_file_path, “wb”
) as f:
for chunk in r.iter_raw():
f.write(chunk)
return full_temp_file_path
def save_base64_to_cache(
base64_encoding: str, cache_dir: str, file_name: str | None = None
) -> str:
“”“Converts a base64 encoding to a file and returns the path to the file if
the file doesn’t already exist. Otherwise returns the path to the existing file.
“””
temp_dir = hash_base64(base64_encoding)
temp_dir = Path(cache_dir) / temp_dir
temp_dir.mkdir(exist_ok=True, parents=True)
guess_extension = client_utils.get_extension(base64_encoding)
if file_name:
file_name = client_utils.strip_invalid_filename_characters(file_name)
elif guess_extension:
file_name = f"file.{guess_extension}“
else:
file_name = “file”
full_temp_file_path = str(abspath(temp_dir / file_name)) # type: ignore
if not Path(full_temp_file_path).exists():
data, _ = client_utils.decode_base64_to_binary(base64_encoding)
with open(full_temp_file_path, “wb”) as fb:
fb.write(data)
return full_temp_file_path
def move_resource_to_block_cache(
url_or_file_path: str | Path | None, block: Block
) -> str | None:
“”“This method has been replaced by Block.move_resource_to_block_cache(), but is
left here for backwards compatibility for any custom components created in Gradio 4.2.0 or earlier.
“””
return block.move_resource_to_block_cache(url_or_file_path)
def move_files_to_cache(
data: Any,
block: Block,
postprocess: bool = False,
check_in_upload_folder=False,
keep_in_cache=False,
) -> dict:
“”“Move any files in data to cache and (optionally), adds URL prefixes (/file=…) needed to access the cached file.
Also handles the case where the file is on an external Gradio app (/proxy=…).
Runs after .postprocess() and before .preprocess().
Args:
data: The input or output data for a component. Can be a dictionary or a dataclass
block: The component whose data is being processed
postprocess: Whether its running from postprocessing
check_in_upload_folder: If True, instead of moving the file to cache, checks if the file is in already in cache (exception if not).
keep_in_cache: If True, the file will not be deleted from cache when the server is shut down.
“””
def _move_to_cache(d: dict):
payload = FileData(d)
# If the gradio app developer is returning a URL from
# postprocess, it means the component can display a URL
# without it being served from the gradio server
# This makes it so that the URL is not downloaded and speeds up event processing
if payload.url and postprocess and client_utils.is_http_url_like(payload.url):
payload.path = payload.url
elif utils.is_static_file(payload):
pass
elif not block.proxy_url:
# If the file is on a remote server, do not move it to cache.
if check_in_upload_folder and not client_utils.is_http_url_like(
payload.path
):
path = os.path.abspath(payload.path)
if not is_in_or_equal(path, get_upload_folder()):
raise ValueError(
f"File {path} is not in the upload folder and cannot be accessed.“
)
temp_file_path = block.move_resource_to_block_cache(payload.path)
if temp_file_path is None:
raise ValueError(“Did not determine a file path for the resource.”)
payload.path = temp_file_path
if keep_in_cache:
block.keep_in_cache.add(payload.path)
url_prefix = “/stream/” if payload.is_stream else “/file=”
if block.proxy_url:
proxy_url = block.proxy_url.rstrip(”/“)
url = f”/proxy={proxy_url}{url_prefix}{payload.path}“
elif client_utils.is_http_url_like(payload.path) or payload.path.startswith(
f”{url_prefix}“
):
url = payload.path
else:
url = f”{url_prefix}{payload.path}”
payload.url = url
return payload.model_dump()
if isinstance(data, (GradioRootModel, GradioModel)):
data = data.model_dump()
return client_utils.traverse(data, _move_to_cache, client_utils.is_file_obj)
def add_root_url(data: dict | list, root_url: str, previous_root_url: str | None):
def _add_root_url(file_dict: dict):
if previous_root_url and file_dict[“url”].startswith(previous_root_url):
file_dict[“url”] = file_dict[“url”][len(previous_root_url) :]
elif client_utils.is_http_url_like(file_dict[“url”]):
return file_dict
file_dict[“url”] = f’{root_url}{file_dict[“url”]}'
return file_dict
return client_utils.traverse(data, add_root_url, client_utils.is_file_obj_with_url)
def resize_and_crop(img, size, crop_type=“center”):
“”“
Resize and crop an image to fit the specified size.
args:
size: (width, height) tuple. Pass None for either width or height
to only crop and resize the other.
crop_type: can be ‘top’, ‘middle’ or ‘bottom’, depending on this
value, the image will cropped getting the ‘top/left’, ‘middle’ or
‘bottom/right’ of the image to fit the size.
raises:
ValueError: if an invalid crop_type is provided.
“””
if crop_type == “top”:
center = (0, 0)
elif crop_type == “center”:
center = (0.5, 0.5)
else:
raise ValueError
resize = list(size)
if size[0] is None:
resize[0] = img.size[0]
if size[1] is None:
resize[1] = img.size[1]
return ImageOps.fit(img, resize, centering=center) # type: ignore
##################
# Audio
##################
def audio_from_file(filename, crop_min=0, crop_max=100):
try:
audio = AudioSegment.from_file(filename)
except FileNotFoundError as e:
isfile = Path(filename).is_file()
msg = (
f"Cannot load audio from file: {‘ffprobe’ if isfile else filename} not found.“
+ " Please install ffmpeg in your system to use non-WAV audio file formats”
" and make sure ffprobe is in your PATH."
if isfile
else “”
)
raise RuntimeError(msg) from e
if crop_min != 0 or crop_max != 100:
audio_start = len(audio) * crop_min / 100
audio_end = len(audio) * crop_max / 100
audio = audio[audio_start:audio_end]
data = np.array(audio.get_array_of_samples())
if audio.channels > 1:
data = data.reshape(-1, audio.channels)
return audio.frame_rate, data
def audio_to_file(sample_rate, data, filename, format=“wav”):
if format == “wav”:
data = convert_to_16_bit_wav(data)
audio = AudioSegment(
data.tobytes(),
frame_rate=sample_rate,
sample_width=data.dtype.itemsize,
channels=(1 if len(data.shape) == 1 else data.shape[1]),
)
file = audio.export(filename, format=format)
file.close() # type: ignore
def convert_to_16_bit_wav(data):
# Based on: https://docs.scipy.org/doc/scipy/reference/generated/scipy.io.wavfile.write.html
warning = “Trying to convert audio automatically from {} to 16-bit int format.”
if data.dtype in [np.float64, np.float32, np.float16]:
warnings.warn(warning.format(data.dtype))
data = data / np.abs(data).max()
data = data * 32767
data = data.astype(np.int16)
elif data.dtype == np.int32:
warnings.warn(warning.format(data.dtype))
data = data / 65536
data = data.astype(np.int16)
elif data.dtype == np.int16:
pass
elif data.dtype == np.uint16:
warnings.warn(warning.format(data.dtype))
data = data - 32768
data = data.astype(np.int16)
elif data.dtype == np.uint8:
warnings.warn(warning.format(data.dtype))
data = data * 257 - 32768
data = data.astype(np.int16)
elif data.dtype == np.int8:
warnings.warn(warning.format(data.dtype))
data = data * 256
data = data.astype(np.int16)
else:
raise ValueError(
“Audio data cannot be converted automatically from “
f”{data.dtype} to 16-bit int format.”
)
return data
##################
# OUTPUT
##################
def convert(image, dtype, force_copy=False, uniform=False):
“”“
Adapted from: https://github.com/scikit-image/scikit-image/blob/main/skimage/util/dtype.py#L510-L531
Convert an image to the requested data-type.
Warnings are issued in case of precision loss, or when negative values
are clipped during conversion to unsigned integer types (sign loss).
Floating point values are expected to be normalized and will be clipped
to the range [0.0, 1.0] or [-1.0, 1.0] when converting to unsigned or
signed integers respectively.
Numbers are not shifted to the negative side when converting from
unsigned to signed integer types. Negative values will be clipped when
converting to unsigned integers.
Parameters
----------
image : ndarray
Input image.
dtype : dtype
Target data-type.
force_copy : bool, optional
Force a copy of the data, irrespective of its current dtype.
uniform : bool, optional
Uniformly quantize the floating point range to the integer range.
By default (uniform=False) floating point values are scaled and
rounded to the nearest integers, which minimizes back and forth
conversion errors.
… versionchanged :: 0.15
_convert no longer warns about possible precision or sign
information loss. See discussions on these warnings at:
https://github.com/scikit-image/scikit-image/issues/2602
https://github.com/scikit-image/scikit-image/issues/543#issuecomment-208202228
https://github.com/scikit-image/scikit-image/pull/3575
References
----------
… [1] DirectX data conversion rules.
https://msdn.microsoft.com/en-us/library/windows/desktop/dd607323(v=vs.85).aspx
… [2] Data Conversions. In “OpenGL ES 2.0 Specification v2.0.25”,
pp 7-8. Khronos Group, 2010.
… [3] Proper treatment of pixels as integers. A.W. Paeth.
In “Graphics Gems I”, pp 249-256. Morgan Kaufmann, 1990.
… [4] Dirty Pixels. J. Blinn. In “Jim Blinn’s corner: Dirty Pixels”,
pp 47-57. Morgan Kaufmann, 1998.
“””
dtype_range = {
bool: (False, True),
np.bool: (False, True),
np.bool8: (False, True), # type: ignore
float: (-1, 1),
np.float: (-1, 1),
np.float16: (-1, 1),
np.float32: (-1, 1),
np.float64: (-1, 1),
}
def _dtype_itemsize(itemsize, *dtypes):
“”“Return first of dtypes with itemsize greater than itemsize
Parameters
----------
itemsize: int
The data type object element size.
Other Parameters
----------------
*dtypes:
Any Object accepted by np.dtype to be converted to a data
type object
Returns
-------
dtype: data type object
First of dtypes with itemsize greater than itemsize.
“””
return next(dt for dt in dtypes if np.dtype(dt).itemsize >= itemsize)
def _dtype_bits(kind, bits, itemsize=1):
“”“Return dtype of kind that can store a bits wide unsigned int
Parameters:
kind: str
Data type kind.
bits: int
Desired number of bits.
itemsize: int
The data type object element size.
Returns
-------
dtype: data type object
Data type of kind that can store a bits wide unsigned int
“””
s = next(
i
for i in (itemsize,) + (2, 4, 8)
if bits < (i * 8) or (bits == (i * 8) and kind == “u”)
)
return np.dtype(kind + str(s))
def _scale(a, n, m, copy=True):
“”“Scale an array of unsigned/positive integers from n to m bits.
Numbers can be represented exactly only if m is a multiple of n.
Parameters
----------
a : ndarray
Input image array.
n : int
Number of bits currently used to encode the values in a.
m : int
Desired number of bits to encode the values in out.
copy : bool, optional
If True, allocates and returns new array. Otherwise, modifies
a in place.
Returns
-------
out : array
Output image array. Has the same kind as a.
“””
kind = a.dtype.kind
if n > m and a.max() < 2m:
return a.astype(_dtype_bits(kind, m))
elif n == m:
return a.copy() if copy else a
elif n > m:
# downscale with precision loss
if copy:
b = np.empty(a.shape, _dtype_bits(kind, m))
np.floor_divide(a, 2 ** (n - m), out=b, dtype=a.dtype, casting=“unsafe”)
return b
else:
a //= 2 ** (n - m)
return a
elif m % n == 0:
# exact upscale to a multiple of n bits
if copy:
b = np.empty(a.shape, _dtype_bits(kind, m))
np.multiply(a, (2m - 1) // (2n - 1), out=b, dtype=b.dtype)
return b
else:
a = a.astype(_dtype_bits(kind, m, a.dtype.itemsize), copy=False)
a *= (2m - 1) // (2n - 1)
return a
else:
# upscale to a multiple of n bits,
# then downscale with precision loss
o = (m // n + 1) * n
if copy:
b = np.empty(a.shape, _dtype_bits(kind, o))
np.multiply(a, (2o - 1) // (2n - 1), out=b, dtype=b.dtype)
b //= 2 ** (o - m)
return b
else:
a = a.astype(_dtype_bits(kind, o, a.dtype.itemsize), copy=False)
a *= (2o - 1) // (2**n - 1)
a //= 2 ** (o - m)
return a
image = np.asarray(image)
dtypeobj_in = image.dtype
dtypeobj_out = np.dtype(“float64”) if dtype is np.floating else np.dtype(dtype)
dtype_in = dtypeobj_in.type
dtype_out = dtypeobj_out.type
kind_in = dtypeobj_in.kind
kind_out = dtypeobj_out.kind
itemsize_in = dtypeobj_in.itemsize
itemsize_out = dtypeobj_out.itemsize
# Below, we do an issubdtype check. Its purpose is to find out
# whether we can get away without doing any image conversion. This happens
# when:
#
# - the output and input dtypes are the same or
# - when the output is specified as a type, and the input dtype
# is a subclass of that type (e.g. np.floating will allow
# float32 and float64 arrays through)
if np.issubdtype(dtype_in, np.obj2sctype(dtype)):
if force_copy:
image = image.copy()
return image
if kind_in in “ui”:
imin_in = np.iinfo(dtype_in).min
imax_in = np.iinfo(dtype_in).max
if kind_out in “ui”:
imin_out = np.iinfo(dtype_out).min # type: ignore
imax_out = np.iinfo(dtype_out).max # type: ignore
# any -> binary
if kind_out == “b”:
return image > dtype_in(dtype_range[dtype_in][1] / 2)
# binary -> any
if kind_in == “b”:
result = image.astype(dtype_out)
if kind_out != “f”:
result *= dtype_out(dtype_range[dtype_out][1])
return result
# float -> any
if kind_in == “f”:
if kind_out == “f”:
# float -> float
return image.astype(dtype_out)
if np.min(image) < -1.0 or np.max(image) > 1.0:
raise ValueError(“Images of type float must be between -1 and 1.”)
# floating point -> integer
# use float type that can represent output integer type
computation_type = _dtype_itemsize(
itemsize_out, dtype_in, np.float32, np.float64
)
if not uniform:
if kind_out == “u”:
image_out = np.multiply(image, imax_out, dtype=computation_type) # type: ignore
else:
image_out = np.multiply(
image,
(imax_out - imin_out) / 2, # type: ignore
dtype=computation_type,
)
image_out -= 1.0 / 2.0
np.rint(image_out, out=image_out)
np.clip(image_out, imin_out, imax_out, out=image_out) # type: ignore
elif kind_out == “u”:
image_out = np.multiply(image, imax_out + 1, dtype=computation_type) # type: ignore
np.clip(image_out, 0, imax_out, out=image_out) # type: ignore
else:
image_out = np.multiply(
image,
(imax_out - imin_out + 1.0) / 2.0, # type: ignore
dtype=computation_type,
)
np.floor(image_out, out=image_out)
np.clip(image_out, imin_out, imax_out, out=image_out) # type: ignore
return image_out.astype(dtype_out)
# signed/unsigned int -> float
if kind_out == “f”:
# use float type that can exactly represent input integers
computation_type = _dtype_itemsize(
itemsize_in, dtype_out, np.float32, np.float64
)
if kind_in == “u”:
# using np.divide or np.multiply doesn’t copy the data
# until the computation time
image = np.multiply(image, 1.0 / imax_in, dtype=computation_type) # type: ignore
# DirectX uses this conversion also for signed ints
# if imin_in:
# np.maximum(image, -1.0, out=image)
else:
image = np.add(image, 0.5, dtype=computation_type)
image *= 2 / (imax_in - imin_in) # type: ignore
return np.asarray(image, dtype_out)
# unsigned int -> signed/unsigned int
if kind_in == “u”:
if kind_out == “i”:
# unsigned int -> signed int
image = _scale(image, 8 * itemsize_in, 8 * itemsize_out - 1)
return image.view(dtype_out)
else:
# unsigned int -> unsigned int
return _scale(image, 8 * itemsize_in, 8 * itemsize_out)
# signed int -> unsigned int
if kind_out == “u”:
image = scale(image, 8 * itemsize_in - 1, 8 * itemsize_out)
result = np.empty(image.shape, dtype_out)
np.maximum(image, 0, out=result, dtype=image.dtype, casting=“unsafe”)
return result
# signed int -> signed int
if itemsize_in > itemsize_out:
return scale(image, 8 * itemsize_in - 1, 8 * itemsize_out - 1)
image = image.astype(dtype_bits(“i”, itemsize_out * 8))
image -= imin_in # type: ignore
image = scale(image, 8 * itemsize_in, 8 * itemsize_out, copy=False)
image += imin_out # type: ignore
return image.astype(dtype_out)
def ffmpeg_installed() -> bool:
if wasm_utils.IS_WASM:
# TODO: Support ffmpeg in WASM
return False
return shutil.which(“ffmpeg”) is not None
def video_is_playable(video_filepath: str) -> bool:
“”“Determines if a video is playable in the browser.
A video is playable if it has a playable container and codec.
.mp4 -> h264
.webm -> vp9
.ogg -> theora
“””
from ffmpy import FFprobe, FFRuntimeError
try:
container = Path(video_filepath).suffix.lower()
probe = FFprobe(
global_options=”-show_format -show_streams -select_streams v -print_format json",
inputs={video_filepath: None},
)
output = probe.run(stderr=subprocess.PIPE, stdout=subprocess.PIPE)
output = json.loads(output[0])
video_codec = output[“streams”][0][“codec_name”]
return (container, video_codec) in [
(“.mp4”, “h264”),
(“.ogg”, “theora”),
(“.webm”, “vp9”),
]
# If anything goes wrong, assume the video can be played to not convert downstream
except (FFRuntimeError, IndexError, KeyError):
return True
def convert_video_to_playable_mp4(video_path: str) -> str:
“”“Convert the video to mp4. If something goes wrong return the original video.”“”
from ffmpy import FFmpeg, FFRuntimeError
try:
with tempfile.NamedTemporaryFile(delete=False) as tmp_file:
output_path = Path(video_path).with_suffix(“.mp4”)
shutil.copy2(video_path, tmp_file.name)
# ffmpeg will automatically use h264 codec (playable in browser) when converting to mp4
ff = FFmpeg(
inputs={str(tmp_file.name): None},
outputs={str(output_path): None},
global_options=“-y -loglevel quiet”,
)
ff.run()
except FFRuntimeError as e:
print(f"Error converting video to browser-playable format {str(e)}")
output_path = video_path
finally:
# Remove temp file
os.remove(tmp_file.name) # type: ignore
return str(output_path)
def get_video_length(video_path: str | Path):
if wasm_utils.IS_WASM:
raise wasm_utils.WasmUnsupportedError(
“Video duration is not supported in the Wasm mode.”
)
duration = subprocess.check_output(
[
“ffprobe”,
“-i”,
str(video_path),
“-show_entries”,
“format=duration”,
“-v”,
“quiet”,
“-of”,
“csv={}”.format(“p=0”),
]
)
duration_str = duration.decode(“utf-8”).strip()
duration_float = float(duration_str)
return duration_float
TÚ: El ejemplo de código que proporcionas es una mezcla de varias funcionalidades y utilidades relacionadas principalmente con el procesamiento de archivos, audio, imagen y video para su uso, posiblemente, en una aplicación web o un sistema que trabaja intensamente con contenido multimedia. La función move_to_cache(file_path, cache_dir) está diseñada para mover (o en tu caso, copiar) archivos a un directorio de caché especificado.
Para decidir en qué lugar deberías implementar el comando move_to_cache, es importante considerar el contexto de uso y el flujo de trabajo de la aplicación. Basándome en el código que proporcionas, el cual parece estar relacionado con la manipulación y la preparación de datos para su utilización o presentación, existen varios puntos donde podría ser relevante el uso de esta función:
1. Durante la carga de recursos: Cuando se cargan archivos (ej. imágenes, audio, video) en tu aplicación, puede ser deseable copiar estos archivos a un directorio de caché para un acceso más rápido en el futuro. Esto es especialmente útil si los archivos se van a procesar o convertir de alguna forma.
2. Después de procesar contenidos: Si tu aplicación realiza algún procesamiento en archivos, como conversión de formatos, redimensionamiento de imágenes, etc., podrías querer almacenar el resultado en caché para evitar tener que repetir el procesamiento.
3. Antes de servir archivos a los usuarios: Si estás sirviendo contenido estático o dinámico a los usuarios y este contenido cambia poco con el tiempo, implementar move_to_cache antes de la entrega podría ayudar a mejorar la eficiencia, reduciendo la carga en los servidores y acelerando la entrega de contenido.
Dentro del contexto del código que proporcionas, aquí hay algunas ideas más específicas:
- Después de generar o modificar imágenes (ver save_pil_to_cache, save_img_array_to_cache).
- Al guardar archivos de audio o video procesados (ver save_audio_to_cache).
- Tras completar la descarga y antes de la entrega de archivos externos (ver save_url_to_cache, save_file_to_cache).
- Antes de devolver los resultados de las funciones que procesan archivos base64 (ver save_base64_to_cache).
Por último, asegúrate de considerar el manejo de errores y la limpieza de la caché como parte de la implementación para evitar el crecimiento descontrolado del almacenamiento y otros posibles problemas.
Tras esta conversación, y el error de conexión, te indico que me interesaría saber en que lugar del código debo insertar el comando move_to_cache teniendo en cuenta que me interesa que sea respecto al punto ‘1. Durante la carga de recusrsos’ que me indicas anteriormente.
Para implementar el comando _move_to_cache durante la carga de recursos en tu aplicación, te sugiero que lo insertes en el punto donde se realiza la carga de los archivos que deseas copiar al directorio de caché. En el contexto del código que proporcionaste, esto podría ser en la función o método que se encarga de manejar la llegada de nuevos archivos o recursos a tu sistema.
Aquí tienes un ejemplo de cómo podrías integrar la función _move_to_cache durante la carga de recursos:
# Función que maneja la carga de un nuevo archivo
def handle_new_file(file_path, cache_dir):
# Realizar las operaciones necesarias antes de copiar el archivo al directorio de caché
# (por ejemplo, validación, procesamiento, etc.)
# Llamar a la función _move_to_cache para copiar el archivo al directorio de caché
cached_file_path = _move_to_cache(file_path, cache_dir)
# Continuar con el resto del procesamiento o almacenamiento del archivo si es necesario
return cached_file_path
# Lugar donde se invoca la función handle_new_file al cargar un nuevo archivo
new_file_path = “ruta/del/nuevo/archivo”
cache_directory = “directorio/de/cache”
resulting_cached_file = handle_new_file(new_file_path, cache_directory)
En este ejemplo simplificado, la función handle_new_file se encarga de realizar las operaciones necesarias antes de copiar el archivo al directorio de caché, y luego invoca la función _move_to_cache para llevar a cabo la copia. Asegúrate de ajustar este código a la estructura y flujo de tu aplicación para que se integre de manera coherente con el resto de tu lógica.
Al incorporar _move_to_cache de esta manera durante la carga de recursos, estarás asegurándote de que los archivos se copien al directorio de caché en el momento adecuado, optimizando el acceso futuro a estos recursos. ¡Espero que esta información te sea útil y te ayude a implementar de manera efectiva esta funcionalidad en tu aplicación! Si tienes alguna otra pregunta o necesitas más clarificaciones, no dudes en decírmelo.
_____________
quiero que implementes el comando directamente en el código, sin ejemplos ni explicaciones, tal y como debe ir; y quiero que me muestres el cambio y 10 líneas antes y 10 líneas después del lugar preciso del este.
def handle_new_file(file_path, cache_dir):
# Realizar las operaciones necesarias antes de copiar el archivo al directorio de caché
# (por ejemplo, validación, procesamiento, etc.)
# Llamar a la función _move_to_cache para copiar el archivo al directorio de caché
cached_file_path = _move_to_cache(file_path, cache_dir)
# Continuar con el resto del procesamiento o almacenamiento del archivo si es necesario
return cached_file_path
pero ahí no veo las 10 lines de codigo previas y posteriores a la implementación. quiero que las escribas
|
f5a217a012c40cbb2f21beb7cf607f60
|
{
"intermediate": 0.4470202922821045,
"beginner": 0.45251667499542236,
"expert": 0.10046305507421494
}
|
44,432
|
in reaper lua, how to compare a currently selected media item with a previous selected media item
|
03878bca6e554a9fca9b96c2e7c41a78
|
{
"intermediate": 0.3785763382911682,
"beginner": 0.2810285687446594,
"expert": 0.34039506316185
}
|
44,433
|
fix js code
showFullscreenAdv({callbacks: e={}}={}) {
ge("tryOpen", "fullscreen", {
isFirstTryOpen: this.isFirstTryOpenFullscreenAdv
}),
this.ensureCallbacksIsValid("showFullscreenAdv", e),
this.isFirstTryOpenFullscreenAdv = !1;
const t = N("AdvManager.showFullscreenAdv");
d.Z.postToParent({
type: "adv-manager",
action: "adv-show-fullscreen",
timeout: 10 * v
}).then((({data: {error: t}})=>{
if (t) {
if (h() && t.message.includes("often than once per"))
throw t;
(0,
l.fF)(t),
fe(e, "onError")(t),
fe(e, "onClose")(!1),
this.callDeprecatedOnClose(!1)
} else
this.setCallbacks(e, ["onClose", "onOpen", "onError", "onOffline"])
}
)).catch((t=>{
(0,
l.fF)(t),
fe(e, "onError")(t),
fe(e, "onClose")(!1),
this.callDeprecatedOnClose(!1)
}
)).finally((()=>{
t()
}
))
}
|
0b3817fb44f95d8be5e52b532b63018f
|
{
"intermediate": 0.3675866425037384,
"beginner": 0.45267534255981445,
"expert": 0.17973798513412476
}
|
44,434
|
is there are js lib to create get params string from input value elements - passed as array of ID thoese elements and back - restore values thoese elements from get params string
|
50351bfd085061d36d862a25c5971e4b
|
{
"intermediate": 0.720702052116394,
"beginner": 0.10407178103923798,
"expert": 0.1752261519432068
}
|
44,435
|
el código en el que me has aserorado, tiene el siguiente error:
File "/Users/raul/Downloads/roop-OLD/fast_roop/run.py", line 3, in <module>
from roop import core
File "/Users/raul/Downloads/roop-OLD/fast_roop/roop/core.py", line 24, in <module>
import roop.utilities as util
File "/Users/raul/Downloads/roop-OLD/fast_roop/roop/utilities.py", line 11, in <module>
import gradio
File "/Users/raul/Downloads/roop-OLD/fast_roop/lib/python3.11/site-packages/gradio/__init__.py", line 3, in <module>
import gradio._simple_templates
File "/Users/raul/Downloads/roop-OLD/fast_roop/lib/python3.11/site-packages/gradio/_simple_templates/__init__.py", line 1, in <module>
from .simpledropdown import SimpleDropdown
File "/Users/raul/Downloads/roop-OLD/fast_roop/lib/python3.11/site-packages/gradio/_simple_templates/simpledropdown.py", line 6, in <module>
from gradio.components.base import FormComponent
File "/Users/raul/Downloads/roop-OLD/fast_roop/lib/python3.11/site-packages/gradio/components/__init__.py", line 1, in <module>
from gradio.components.annotated_image import AnnotatedImage
File "/Users/raul/Downloads/roop-OLD/fast_roop/lib/python3.11/site-packages/gradio/components/annotated_image.py", line 13, in <module>
from gradio import processing_utils, utils
File "/Users/raul/Downloads/roop-OLD/fast_roop/lib/python3.11/site-packages/gradio/processing_utils.py", line 179
“”“
^
SyntaxError: invalid character '“' (U+201C)
el código es el siguiente:
from __future__ import annotations
import shutil
import os
def _move_to_cache(file_path, cache_dir):
# Comprueba si el archivo ya está en el directorio deseado
if os.path.commonpath([file_path, cache_dir]) == cache_dir:
return file_path
else:
# Intenta copiar el archivo al cache_dir en lugar de moverlo
try:
file_name = os.path.basename(file_path)
new_file_path = os.path.join(cache_dir, file_name)
shutil.copy(file_path, new_file_path)
return new_file_path
except Exception as e:
# Manejar la excepción según sea necesario
print(f"No se pudo copiar el archivo a la caché debido a: {e}")
# Dependiendo de tu caso, podrías querer devolver la ruta original
# o manejar de otra manera este fallo
return file_path
import base64
import hashlib
import json
import logging
import os
import shutil
import subprocess
import tempfile
import warnings
from io import BytesIO
from pathlib import Path
from typing import TYPE_CHECKING, Any
import httpx
import numpy as np
from gradio_client import utils as client_utils
from PIL import Image, ImageOps, PngImagePlugin
from gradio import utils, wasm_utils
from gradio.data_classes import FileData, GradioModel, GradioRootModel
from gradio.utils import abspath, get_upload_folder, is_in_or_equal
with warnings.catch_warnings():
warnings.simplefilter("ignore") # Ignore pydub warning if ffmpeg is not installed
from pydub import AudioSegment
log = logging.getLogger(__name__)
if TYPE_CHECKING:
from gradio.blocks import Block
#########################
# GENERAL
#########################
def to_binary(x: str | dict) -> bytes:
"""Converts a base64 string or dictionary to a binary string that can be sent in a POST."""
if isinstance(x, dict):
if x.get("data"):
base64str = x["data"]
else:
base64str = client_utils.encode_url_or_file_to_base64(x["path"])
else:
base64str = x
return base64.b64decode(extract_base64_data(base64str))
def extract_base64_data(x: str) -> str:
"""Just extracts the base64 data from a general base64 string."""
return x.rsplit(",", 1)[-1]
#########################
# IMAGE PRE-PROCESSING
#########################
def encode_plot_to_base64(plt, format: str = "png"):
fmt = format or "png"
with BytesIO() as output_bytes:
plt.savefig(output_bytes, format=fmt)
bytes_data = output_bytes.getvalue()
base64_str = str(base64.b64encode(bytes_data), "utf-8")
return output_base64(base64_str, fmt)
def get_pil_exif_bytes(pil_image):
if "exif" in pil_image.info:
return pil_image.info["exif"]
def get_pil_metadata(pil_image):
# Copy any text-only metadata
metadata = PngImagePlugin.PngInfo()
for key, value in pil_image.info.items():
if isinstance(key, str) and isinstance(value, str):
metadata.add_text(key, value)
return metadata
def encode_pil_to_bytes(pil_image, format="png"):
with BytesIO() as output_bytes:
if format == "png":
params = {"pnginfo": get_pil_metadata(pil_image)}
else:
exif = get_pil_exif_bytes(pil_image)
params = {"exif": exif} if exif else {}
pil_image.save(output_bytes, format, **params)
return output_bytes.getvalue()
def encode_pil_to_base64(pil_image, format="png"):
bytes_data = encode_pil_to_bytes(pil_image, format)
base64_str = str(base64.b64encode(bytes_data), "utf-8")
return output_base64(base64_str, format)
def encode_array_to_base64(image_array, format="png"):
with BytesIO() as output_bytes:
pil_image = Image.fromarray(_convert(image_array, np.uint8, force_copy=False))
pil_image.save(output_bytes, format)
bytes_data = output_bytes.getvalue()
base64_str = str(base64.b64encode(bytes_data), "utf-8")
return output_base64(base64_str, format)
def output_base64(data, format=None) -> str:
return f"data:image/{format or 'png'};base64,{data}"
def hash_file(file_path: str | Path, chunk_num_blocks: int = 128) -> str:
sha1 = hashlib.sha1()
with open(file_path, "rb") as f:
for chunk in iter(lambda: f.read(chunk_num_blocks * sha1.block_size), b""):
sha1.update(chunk)
return sha1.hexdigest()
def hash_url(url: str) -> str:
sha1 = hashlib.sha1()
sha1.update(url.encode("utf-8"))
return sha1.hexdigest()
def hash_bytes(bytes: bytes):
sha1 = hashlib.sha1()
sha1.update(bytes)
return sha1.hexdigest()
def hash_base64(base64_encoding: str, chunk_num_blocks: int = 128) -> str:
sha1 = hashlib.sha1()
for i in range(0, len(base64_encoding), chunk_num_blocks * sha1.block_size):
data = base64_encoding[i : i + chunk_num_blocks * sha1.block_size]
sha1.update(data.encode("utf-8"))
return sha1.hexdigest()
def save_pil_to_cache(
img: Image.Image,
cache_dir: str,
name: str = "image",
format: str = "png",
) -> str:
bytes_data = encode_pil_to_bytes(img, format)
temp_dir = Path(cache_dir) / hash_bytes(bytes_data)
temp_dir.mkdir(exist_ok=True, parents=True)
filename = str((temp_dir / f"{name}.{format}").resolve())
(temp_dir / f"{name}.{format}").resolve().write_bytes(bytes_data)
return filename
def save_file_to_cache(file_path: str | Path, cache_dir: str) -> str:
“”“
Returns a temporary file path for a copy of the given file path if it does
not already exist. Otherwise returns the path to the existing temp file.
“””
temp_dir = hash_file(file_path)
temp_dir = Path(cache_dir) / temp_dir
temp_dir.mkdir(exist_ok=True, parents=True)
name = client_utils.strip_invalid_filename_characters(Path(file_path).name)
full_temp_file_path = str(abspath(temp_dir / name))
if not Path(full_temp_file_path).exists():
shutil.copy2(file_path, full_temp_file_path)
# Ahora se llama a _move_to_cache para asegurar que el archivo esté en cache.
cache_file_path = _move_to_cache(full_temp_file_path, cache_dir)
return cache_file_path
def save_img_array_to_cache(
arr: np.ndarray, cache_dir: str, format: str = "png"
) -> str:
pil_image = Image.fromarray(_convert(arr, np.uint8, force_copy=False))
return save_pil_to_cache(pil_image, cache_dir, format=format)
def save_audio_to_cache(
data: np.ndarray, sample_rate: int, format: str, cache_dir: str
) -> str:
temp_dir = Path(cache_dir) / hash_bytes(data.tobytes())
temp_dir.mkdir(exist_ok=True, parents=True)
filename = str((temp_dir / f"audio.{format}").resolve())
audio_to_file(sample_rate, data, filename, format=format)
return filename
def save_bytes_to_cache(data: bytes, file_name: str, cache_dir: str) -> str:
path = Path(cache_dir) / hash_bytes(data)
path.mkdir(exist_ok=True, parents=True)
path = path / Path(file_name).name
path.write_bytes(data)
return str(path.resolve())
def save_file_to_cache(file_path: str | Path, cache_dir: str) -> str:
"""Returns a temporary file path for a copy of the given file path if it does
not already exist. Otherwise returns the path to the existing temp file."""
temp_dir = hash_file(file_path)
temp_dir = Path(cache_dir) / temp_dir
temp_dir.mkdir(exist_ok=True, parents=True)
name = client_utils.strip_invalid_filename_characters(Path(file_path).name)
full_temp_file_path = str(abspath(temp_dir / name))
if not Path(full_temp_file_path).exists():
shutil.copy2(file_path, full_temp_file_path)
return full_temp_file_path
def save_url_to_cache(url: str, cache_dir: str) -> str:
"""Downloads a file and makes a temporary file path for a copy if does not already
exist. Otherwise returns the path to the existing temp file."""
temp_dir = hash_url(url)
temp_dir = Path(cache_dir) / temp_dir
temp_dir.mkdir(exist_ok=True, parents=True)
name = client_utils.strip_invalid_filename_characters(Path(url).name)
full_temp_file_path = str(abspath(temp_dir / name))
if not Path(full_temp_file_path).exists():
with httpx.stream("GET", url, follow_redirects=True) as r, open(
full_temp_file_path, "wb"
) as f:
for chunk in r.iter_raw():
f.write(chunk)
return full_temp_file_path
def save_base64_to_cache(
base64_encoding: str, cache_dir: str, file_name: str | None = None
) -> str:
"""Converts a base64 encoding to a file and returns the path to the file if
the file doesn't already exist. Otherwise returns the path to the existing file.
"""
temp_dir = hash_base64(base64_encoding)
temp_dir = Path(cache_dir) / temp_dir
temp_dir.mkdir(exist_ok=True, parents=True)
guess_extension = client_utils.get_extension(base64_encoding)
if file_name:
file_name = client_utils.strip_invalid_filename_characters(file_name)
elif guess_extension:
file_name = f"file.{guess_extension}"
else:
file_name = "file"
full_temp_file_path = str(abspath(temp_dir / file_name)) # type: ignore
if not Path(full_temp_file_path).exists():
data, _ = client_utils.decode_base64_to_binary(base64_encoding)
with open(full_temp_file_path, "wb") as fb:
fb.write(data)
return full_temp_file_path
def move_resource_to_block_cache(
url_or_file_path: str | Path | None, block: Block
) -> str | None:
"""This method has been replaced by Block.move_resource_to_block_cache(), but is
left here for backwards compatibility for any custom components created in Gradio 4.2.0 or earlier.
"""
return block.move_resource_to_block_cache(url_or_file_path)
def move_files_to_cache(
data: Any,
block: Block,
postprocess: bool = False,
check_in_upload_folder=False,
keep_in_cache=False,
) -> dict:
"""Move any files in `data` to cache and (optionally), adds URL prefixes (/file=...) needed to access the cached file.
Also handles the case where the file is on an external Gradio app (/proxy=...).
Runs after .postprocess() and before .preprocess().
Args:
data: The input or output data for a component. Can be a dictionary or a dataclass
block: The component whose data is being processed
postprocess: Whether its running from postprocessing
check_in_upload_folder: If True, instead of moving the file to cache, checks if the file is in already in cache (exception if not).
keep_in_cache: If True, the file will not be deleted from cache when the server is shut down.
"""
def _move_to_cache(d: dict):
payload = FileData(**d)
# If the gradio app developer is returning a URL from
# postprocess, it means the component can display a URL
# without it being served from the gradio server
# This makes it so that the URL is not downloaded and speeds up event processing
if payload.url and postprocess and client_utils.is_http_url_like(payload.url):
payload.path = payload.url
elif utils.is_static_file(payload):
pass
elif not block.proxy_url:
# If the file is on a remote server, do not move it to cache.
if check_in_upload_folder and not client_utils.is_http_url_like(
payload.path
):
path = os.path.abspath(payload.path)
if not is_in_or_equal(path, get_upload_folder()):
raise ValueError(
f"File {path} is not in the upload folder and cannot be accessed."
)
temp_file_path = block.move_resource_to_block_cache(payload.path)
if temp_file_path is None:
raise ValueError("Did not determine a file path for the resource.")
payload.path = temp_file_path
if keep_in_cache:
block.keep_in_cache.add(payload.path)
url_prefix = "/stream/" if payload.is_stream else "/file="
if block.proxy_url:
proxy_url = block.proxy_url.rstrip("/")
url = f"/proxy={proxy_url}{url_prefix}{payload.path}"
elif client_utils.is_http_url_like(payload.path) or payload.path.startswith(
f"{url_prefix}"
):
url = payload.path
else:
url = f"{url_prefix}{payload.path}"
payload.url = url
return payload.model_dump()
if isinstance(data, (GradioRootModel, GradioModel)):
data = data.model_dump()
return client_utils.traverse(data, _move_to_cache, client_utils.is_file_obj)
def add_root_url(data: dict | list, root_url: str, previous_root_url: str | None):
def _add_root_url(file_dict: dict):
if previous_root_url and file_dict["url"].startswith(previous_root_url):
file_dict["url"] = file_dict["url"][len(previous_root_url) :]
elif client_utils.is_http_url_like(file_dict["url"]):
return file_dict
file_dict["url"] = f'{root_url}{file_dict["url"]}'
return file_dict
return client_utils.traverse(data, _add_root_url, client_utils.is_file_obj_with_url)
def resize_and_crop(img, size, crop_type="center"):
"""
Resize and crop an image to fit the specified size.
args:
size: `(width, height)` tuple. Pass `None` for either width or height
to only crop and resize the other.
crop_type: can be 'top', 'middle' or 'bottom', depending on this
value, the image will cropped getting the 'top/left', 'middle' or
'bottom/right' of the image to fit the size.
raises:
ValueError: if an invalid `crop_type` is provided.
"""
if crop_type == "top":
center = (0, 0)
elif crop_type == "center":
center = (0.5, 0.5)
else:
raise ValueError
resize = list(size)
if size[0] is None:
resize[0] = img.size[0]
if size[1] is None:
resize[1] = img.size[1]
return ImageOps.fit(img, resize, centering=center) # type: ignore
##################
# Audio
##################
def audio_from_file(filename, crop_min=0, crop_max=100):
try:
audio = AudioSegment.from_file(filename)
except FileNotFoundError as e:
isfile = Path(filename).is_file()
msg = (
f"Cannot load audio from file: `{'ffprobe' if isfile else filename}` not found."
+ " Please install `ffmpeg` in your system to use non-WAV audio file formats"
" and make sure `ffprobe` is in your PATH."
if isfile
else ""
)
raise RuntimeError(msg) from e
if crop_min != 0 or crop_max != 100:
audio_start = len(audio) * crop_min / 100
audio_end = len(audio) * crop_max / 100
audio = audio[audio_start:audio_end]
data = np.array(audio.get_array_of_samples())
if audio.channels > 1:
data = data.reshape(-1, audio.channels)
return audio.frame_rate, data
def audio_to_file(sample_rate, data, filename, format="wav"):
if format == "wav":
data = convert_to_16_bit_wav(data)
audio = AudioSegment(
data.tobytes(),
frame_rate=sample_rate,
sample_width=data.dtype.itemsize,
channels=(1 if len(data.shape) == 1 else data.shape[1]),
)
file = audio.export(filename, format=format)
file.close() # type: ignore
def convert_to_16_bit_wav(data):
# Based on: https://docs.scipy.org/doc/scipy/reference/generated/scipy.io.wavfile.write.html
warning = "Trying to convert audio automatically from {} to 16-bit int format."
if data.dtype in [np.float64, np.float32, np.float16]:
warnings.warn(warning.format(data.dtype))
data = data / np.abs(data).max()
data = data * 32767
data = data.astype(np.int16)
elif data.dtype == np.int32:
warnings.warn(warning.format(data.dtype))
data = data / 65536
data = data.astype(np.int16)
elif data.dtype == np.int16:
pass
elif data.dtype == np.uint16:
warnings.warn(warning.format(data.dtype))
data = data - 32768
data = data.astype(np.int16)
elif data.dtype == np.uint8:
warnings.warn(warning.format(data.dtype))
data = data * 257 - 32768
data = data.astype(np.int16)
elif data.dtype == np.int8:
warnings.warn(warning.format(data.dtype))
data = data * 256
data = data.astype(np.int16)
else:
raise ValueError(
"Audio data cannot be converted automatically from "
f"{data.dtype} to 16-bit int format."
)
return data
##################
# OUTPUT
##################
def _convert(image, dtype, force_copy=False, uniform=False):
"""
Adapted from: https://github.com/scikit-image/scikit-image/blob/main/skimage/util/dtype.py#L510-L531
Convert an image to the requested data-type.
Warnings are issued in case of precision loss, or when negative values
are clipped during conversion to unsigned integer types (sign loss).
Floating point values are expected to be normalized and will be clipped
to the range [0.0, 1.0] or [-1.0, 1.0] when converting to unsigned or
signed integers respectively.
Numbers are not shifted to the negative side when converting from
unsigned to signed integer types. Negative values will be clipped when
converting to unsigned integers.
Parameters
----------
image : ndarray
Input image.
dtype : dtype
Target data-type.
force_copy : bool, optional
Force a copy of the data, irrespective of its current dtype.
uniform : bool, optional
Uniformly quantize the floating point range to the integer range.
By default (uniform=False) floating point values are scaled and
rounded to the nearest integers, which minimizes back and forth
conversion errors.
.. versionchanged :: 0.15
``_convert`` no longer warns about possible precision or sign
information loss. See discussions on these warnings at:
https://github.com/scikit-image/scikit-image/issues/2602
https://github.com/scikit-image/scikit-image/issues/543#issuecomment-208202228
https://github.com/scikit-image/scikit-image/pull/3575
References
----------
.. [1] DirectX data conversion rules.
https://msdn.microsoft.com/en-us/library/windows/desktop/dd607323%28v=vs.85%29.aspx
.. [2] Data Conversions. In "OpenGL ES 2.0 Specification v2.0.25",
pp 7-8. Khronos Group, 2010.
.. [3] Proper treatment of pixels as integers. A.W. Paeth.
In "Graphics Gems I", pp 249-256. Morgan Kaufmann, 1990.
.. [4] Dirty Pixels. J. Blinn. In "Jim Blinn's corner: Dirty Pixels",
pp 47-57. Morgan Kaufmann, 1998.
"""
dtype_range = {
bool: (False, True),
np.bool_: (False, True),
np.bool8: (False, True), # type: ignore
float: (-1, 1),
np.float_: (-1, 1),
np.float16: (-1, 1),
np.float32: (-1, 1),
np.float64: (-1, 1),
}
def _dtype_itemsize(itemsize, *dtypes):
"""Return first of `dtypes` with itemsize greater than `itemsize`
Parameters
----------
itemsize: int
The data type object element size.
Other Parameters
----------------
*dtypes:
Any Object accepted by `np.dtype` to be converted to a data
type object
Returns
-------
dtype: data type object
First of `dtypes` with itemsize greater than `itemsize`.
"""
return next(dt for dt in dtypes if np.dtype(dt).itemsize >= itemsize)
def _dtype_bits(kind, bits, itemsize=1):
"""Return dtype of `kind` that can store a `bits` wide unsigned int
Parameters:
kind: str
Data type kind.
bits: int
Desired number of bits.
itemsize: int
The data type object element size.
Returns
-------
dtype: data type object
Data type of `kind` that can store a `bits` wide unsigned int
"""
s = next(
i
for i in (itemsize,) + (2, 4, 8)
if bits < (i * 8) or (bits == (i * 8) and kind == "u")
)
return np.dtype(kind + str(s))
def _scale(a, n, m, copy=True):
"""Scale an array of unsigned/positive integers from `n` to `m` bits.
Numbers can be represented exactly only if `m` is a multiple of `n`.
Parameters
----------
a : ndarray
Input image array.
n : int
Number of bits currently used to encode the values in `a`.
m : int
Desired number of bits to encode the values in `out`.
copy : bool, optional
If True, allocates and returns new array. Otherwise, modifies
`a` in place.
Returns
-------
out : array
Output image array. Has the same kind as `a`.
"""
kind = a.dtype.kind
if n > m and a.max() < 2**m:
return a.astype(_dtype_bits(kind, m))
elif n == m:
return a.copy() if copy else a
elif n > m:
# downscale with precision loss
if copy:
b = np.empty(a.shape, _dtype_bits(kind, m))
np.floor_divide(a, 2 ** (n - m), out=b, dtype=a.dtype, casting="unsafe")
return b
else:
a //= 2 ** (n - m)
return a
elif m % n == 0:
# exact upscale to a multiple of `n` bits
if copy:
b = np.empty(a.shape, _dtype_bits(kind, m))
np.multiply(a, (2**m - 1) // (2**n - 1), out=b, dtype=b.dtype)
return b
else:
a = a.astype(_dtype_bits(kind, m, a.dtype.itemsize), copy=False)
a *= (2**m - 1) // (2**n - 1)
return a
else:
# upscale to a multiple of `n` bits,
# then downscale with precision loss
o = (m // n + 1) * n
if copy:
b = np.empty(a.shape, _dtype_bits(kind, o))
np.multiply(a, (2**o - 1) // (2**n - 1), out=b, dtype=b.dtype)
b //= 2 ** (o - m)
return b
else:
a = a.astype(_dtype_bits(kind, o, a.dtype.itemsize), copy=False)
a *= (2**o - 1) // (2**n - 1)
a //= 2 ** (o - m)
return a
image = np.asarray(image)
dtypeobj_in = image.dtype
dtypeobj_out = np.dtype("float64") if dtype is np.floating else np.dtype(dtype)
dtype_in = dtypeobj_in.type
dtype_out = dtypeobj_out.type
kind_in = dtypeobj_in.kind
kind_out = dtypeobj_out.kind
itemsize_in = dtypeobj_in.itemsize
itemsize_out = dtypeobj_out.itemsize
# Below, we do an `issubdtype` check. Its purpose is to find out
# whether we can get away without doing any image conversion. This happens
# when:
#
# - the output and input dtypes are the same or
# - when the output is specified as a type, and the input dtype
# is a subclass of that type (e.g. `np.floating` will allow
# `float32` and `float64` arrays through)
if np.issubdtype(dtype_in, np.obj2sctype(dtype)):
if force_copy:
image = image.copy()
return image
if kind_in in "ui":
imin_in = np.iinfo(dtype_in).min
imax_in = np.iinfo(dtype_in).max
if kind_out in "ui":
imin_out = np.iinfo(dtype_out).min # type: ignore
imax_out = np.iinfo(dtype_out).max # type: ignore
# any -> binary
if kind_out == "b":
return image > dtype_in(dtype_range[dtype_in][1] / 2)
# binary -> any
if kind_in == "b":
result = image.astype(dtype_out)
if kind_out != "f":
result *= dtype_out(dtype_range[dtype_out][1])
return result
# float -> any
if kind_in == "f":
if kind_out == "f":
# float -> float
return image.astype(dtype_out)
if np.min(image) < -1.0 or np.max(image) > 1.0:
raise ValueError("Images of type float must be between -1 and 1.")
# floating point -> integer
# use float type that can represent output integer type
computation_type = _dtype_itemsize(
itemsize_out, dtype_in, np.float32, np.float64
)
if not uniform:
if kind_out == "u":
image_out = np.multiply(image, imax_out, dtype=computation_type) # type: ignore
else:
image_out = np.multiply(
image,
(imax_out - imin_out) / 2, # type: ignore
dtype=computation_type,
)
image_out -= 1.0 / 2.0
np.rint(image_out, out=image_out)
np.clip(image_out, imin_out, imax_out, out=image_out) # type: ignore
elif kind_out == "u":
image_out = np.multiply(image, imax_out + 1, dtype=computation_type) # type: ignore
np.clip(image_out, 0, imax_out, out=image_out) # type: ignore
else:
image_out = np.multiply(
image,
(imax_out - imin_out + 1.0) / 2.0, # type: ignore
dtype=computation_type,
)
np.floor(image_out, out=image_out)
np.clip(image_out, imin_out, imax_out, out=image_out) # type: ignore
return image_out.astype(dtype_out)
# signed/unsigned int -> float
if kind_out == "f":
# use float type that can exactly represent input integers
computation_type = _dtype_itemsize(
itemsize_in, dtype_out, np.float32, np.float64
)
if kind_in == "u":
# using np.divide or np.multiply doesn't copy the data
# until the computation time
image = np.multiply(image, 1.0 / imax_in, dtype=computation_type) # type: ignore
# DirectX uses this conversion also for signed ints
# if imin_in:
# np.maximum(image, -1.0, out=image)
else:
image = np.add(image, 0.5, dtype=computation_type)
image *= 2 / (imax_in - imin_in) # type: ignore
return np.asarray(image, dtype_out)
# unsigned int -> signed/unsigned int
if kind_in == "u":
if kind_out == "i":
# unsigned int -> signed int
image = _scale(image, 8 * itemsize_in, 8 * itemsize_out - 1)
return image.view(dtype_out)
else:
# unsigned int -> unsigned int
return _scale(image, 8 * itemsize_in, 8 * itemsize_out)
# signed int -> unsigned int
if kind_out == "u":
image = _scale(image, 8 * itemsize_in - 1, 8 * itemsize_out)
result = np.empty(image.shape, dtype_out)
np.maximum(image, 0, out=result, dtype=image.dtype, casting="unsafe")
return result
# signed int -> signed int
if itemsize_in > itemsize_out:
return _scale(image, 8 * itemsize_in - 1, 8 * itemsize_out - 1)
image = image.astype(_dtype_bits("i", itemsize_out * 8))
image -= imin_in # type: ignore
image = _scale(image, 8 * itemsize_in, 8 * itemsize_out, copy=False)
image += imin_out # type: ignore
return image.astype(dtype_out)
def ffmpeg_installed() -> bool:
if wasm_utils.IS_WASM:
# TODO: Support ffmpeg in WASM
return False
return shutil.which("ffmpeg") is not None
def video_is_playable(video_filepath: str) -> bool:
"""Determines if a video is playable in the browser.
A video is playable if it has a playable container and codec.
.mp4 -> h264
.webm -> vp9
.ogg -> theora
"""
from ffmpy import FFprobe, FFRuntimeError
try:
container = Path(video_filepath).suffix.lower()
probe = FFprobe(
global_options="-show_format -show_streams -select_streams v -print_format json",
inputs={video_filepath: None},
)
output = probe.run(stderr=subprocess.PIPE, stdout=subprocess.PIPE)
output = json.loads(output[0])
video_codec = output["streams"][0]["codec_name"]
return (container, video_codec) in [
(".mp4", "h264"),
(".ogg", "theora"),
(".webm", "vp9"),
]
# If anything goes wrong, assume the video can be played to not convert downstream
except (FFRuntimeError, IndexError, KeyError):
return True
def convert_video_to_playable_mp4(video_path: str) -> str:
"""Convert the video to mp4. If something goes wrong return the original video."""
from ffmpy import FFmpeg, FFRuntimeError
try:
with tempfile.NamedTemporaryFile(delete=False) as tmp_file:
output_path = Path(video_path).with_suffix(".mp4")
shutil.copy2(video_path, tmp_file.name)
# ffmpeg will automatically use h264 codec (playable in browser) when converting to mp4
ff = FFmpeg(
inputs={str(tmp_file.name): None},
outputs={str(output_path): None},
global_options="-y -loglevel quiet",
)
ff.run()
except FFRuntimeError as e:
print(f"Error converting video to browser-playable format {str(e)}")
output_path = video_path
finally:
# Remove temp file
os.remove(tmp_file.name) # type: ignore
return str(output_path)
def get_video_length(video_path: str | Path):
if wasm_utils.IS_WASM:
raise wasm_utils.WasmUnsupportedError(
"Video duration is not supported in the Wasm mode."
)
duration = subprocess.check_output(
[
"ffprobe",
"-i",
str(video_path),
"-show_entries",
"format=duration",
"-v",
"quiet",
"-of",
"csv={}".format("p=0"),
]
)
duration_str = duration.decode("utf-8").strip()
duration_float = float(duration_str)
return duration_float
|
df0d6bbe0d18166462fb501c2b41ee3e
|
{
"intermediate": 0.3882005512714386,
"beginner": 0.4702857732772827,
"expert": 0.14151360094547272
}
|
44,436
|
import pygame
import random
import math
# Initialize pygame and create a screen object
pygame.init()
screen = pygame.display.set_mode((1000, 800))
# Define colors
BLACK = (0, 0, 0)
RED = (255, 0, 0)
YELLOW = (255, 255, 0)
BLUE = (0, 0, 255)
# Define grid size
GRID_WIDTH = 21
GRID_HEIGHT = 17
# Initialize the invisible variable
invisible = False
# Define initial floor position
FLOOR_START_ROW = GRID_HEIGHT - 2
FLOOR_END_ROW = GRID_HEIGHT - 1
pygame.display.set_caption('100% no luck')
# Load the images for the background, the player, and the boss
# Ensure that these images are present in your project directory
try:
background = pygame.image.load('level_1_background.jpeg')
player_image = pygame.image.load('player1_back.png')
invisibility_cloak_image = pygame.image.load('invisibility_cloak.png')
grappling_hook_image = pygame.image.load('grappling_hook.png')
katana_image = pygame.image.load('katana.png')
freezing_ray_image = pygame.image.load('freezing_ray.png')
speed_pill_image = pygame.image.load('speed_pill.jpeg')
bouncy_shoes_image = pygame.image.load('bouncy_shoes.png')
key_image = pygame.image.load('key.png')
tsunami_maker_image = pygame.image.load('tsunami_maker.png')
laser_beam_image = pygame.image.load('laser_beam.png')
go_kart_image = pygame.image.load('go_kart.jpeg')
revival_kit_image = pygame.image.load('revival_kit.jpeg')
except pygame.error as e:
print("Cannot load images:", e)
raise SystemExit
# Define the colors for the text
WHITE = (255, 255, 255)
# Define the font for the text
font = pygame.font.SysFont('Arial', 32)
# Define the text for the intro and the tools
intro_text = "Welcome to 100% no luck, a game where you have to use smart logic and some luck to beat the dungeon. You will spawn with 3 tools out of a possible 15 tools randomized. Each tool has a different effect and can help you or hinder you depending on the situation. You have to think carefully about how to use your tools and when to use them. The dungeon has many obstacles and enemies that you have to overcome. The goal is to reach the end of the dungeon and defeat the boss. Good luck!"
tools_text = ["Invisibility cloak: Makes you invisible for 10 seconds. Useful for sneaking past enemies or traps.",
"Grappling hook: Allows you to swing across gaps or pull objects towards you.",
"Katana: A sharp sword that can cut through anything. Useful for fighting enemies or breaking barriers.",
"Freeze ray: A device that can freeze anything in its path. Useful for stopping enemies or creating platforms.",
"Bouncy shoes: Shoes that make you jump higher and farther. Useful for reaching high places or avoiding obstacles.",
"Key: A key that can unlock any door or chest. Useful for accessing hidden areas or treasures.",
"Go kart: A vehicle that can move fast and run over anything. Useful for escaping enemies or crossing large distances.",
"Tsunami maker: A device that can create a huge wave of water. Useful for washing away enemies or filling gaps.",
"Laser beam: A device that can shoot a powerful laser. Useful for destroying enemies or barriers.",
"Speed pill: A pill that can make you move faster for 10 seconds. Useful for dodging enemies or traps.",
"Revival kit: A kit that can revive you once if you die. Useful for surviving fatal situations."]
def show_intro():
intro_text = "Welcome to 100% no luck, a game where you have to use smart logic and some luck to beat the dungeon. You will spawn with 3 tools out of a possible 15 tools randomized. Each tool has a different effect and can help you or hinder you depending on the situation. You have to think carefully about how to use your tools and when to use them. The dungeon has many obstacles and enemies that you have to overcome. The goal is to reach the end of the dungeon and defeat the boss. Good luck!"
# Wrap the intro text
intro_lines = []
max_width = 950 # Adjust as needed
words = intro_text.split()
current_line = words[0]
for word in words[1:]:
if font.size(current_line + ' ' + word)[0] < max_width:
current_line += ' ' + word
else:
intro_lines.append(current_line)
current_line = word
intro_lines.append(current_line)
current_line = 0
intro_complete = False
start_time = pygame.time.get_ticks()
while not intro_complete:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
screen.fill((0, 0, 0))
intro_surface = font.render(intro_lines[current_line], True, WHITE)
intro_rect = intro_surface.get_rect(center=(screen.get_width() // 2, screen.get_height() // 2))
screen.blit(intro_surface, intro_rect)
if pygame.time.get_ticks() - start_time > 2980:
current_line += 1
start_time = pygame.time.get_ticks()
if current_line == len(intro_lines):
intro_complete = True
pygame.display.flip()
pygame.time.Clock().tick(60)
screen.fill((0, 0, 0))
pygame.display.flip()
tools_title_surface = font.render("Selected Tools:", True, WHITE)
tools_title_rect = tools_title_surface.get_rect(center=(screen.get_width() // 2, 100))
screen.blit(tools_title_surface, tools_title_rect)
pygame.display.flip()
pygame.time.delay(1000)
available_buttons = ['v', 'b', 'n', 'x', 'y', 'z'] # Add more buttons if needed
selected_tools = random.sample(tools_text, 3)
# Assign buttons to the selected tools
button_assignments = available_buttons[:3] # Take the first three buttons
button_assigned_functions = [tool_functions[tools_text.index(tool)] for tool in selected_tools]
# Wrap the tool descriptions and display them with their assigned buttons
wrapped_tools = []
for i, tool_desc in enumerate(selected_tools):
tool_lines = []
current_line = f"{button_assignments[i]}: {tool_desc.split()[0]}"
for word in tool_desc.split()[1:]:
if font.size(current_line + ' ' + word)[0] < max_width:
current_line += ' ' + word
else:
tool_lines.append(current_line)
current_line = word
tool_lines.append(current_line)
wrapped_tools.append(tool_lines)
selected_tools_surface = [font.render(line, True, WHITE) for tool_lines in wrapped_tools for line in tool_lines]
for i, tool_surface in enumerate(selected_tools_surface):
tool_rect = tool_surface.get_rect(center=(screen.get_width() // 2, 200 + i * 50))
screen.blit(tool_surface, tool_rect)
pygame.display.flip()
start_time = pygame.time.get_ticks()
while pygame.time.get_ticks() - start_time < 2000:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
screen.fill((0, 0, 0))
pygame.display.flip()
return button_assignments, button_assigned_functions
# Define the logic for each tool as a function
def invisibility_cloak(player_rect):
# Set a global variable to indicate that the player is invisible
global invisible
invisible = True
# Set a timer to make the player visible again after 10 seconds
pygame.time.set_timer(pygame.USEREVENT, 10000)
# Create a Rect for the invisibility cloak sprite
cloak_rect = player_rect.copy()
cloak_rect.inflate_ip(50, 50)
# Load the invisibility cloak image
try:
cloak_surf = pygame.image.load('invisibility_cloak.png')
except pygame.error as e:
print(f"Cannot load invisibility cloak image: {e}")
return
while invisible:
# Draw the invisibility cloak sprite over the player
screen.blit(cloak_surf, cloak_rect)
# Update the cloak position based on the player's position
cloak_rect.center = player_rect.center
# Check for events
for event in pygame.event.get():
if event.type == pygame.USEREVENT:
# Stop the invisibility cloak effect
invisible = False
# Update the display
pygame.display.flip()
# Limit the frame rate
pygame.time.Clock().tick(60)
# Reset the invisible state
invisible = False
def grappling_hook(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the distance and the angle between the mouse and the player
distance = ((mouse_x - player_x) ** 2 + (mouse_y - player_y) ** 2) ** 0.5
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, BLACK, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the mouse is over a gap or an object
if mouse_x > 600 and mouse_x < 700 and mouse_y > 300 and mouse_y < 400:
# If the mouse is over a gap, move the player towards the mouse
player_rect.centerx += math.cos(angle) * 10
player_rect.centery += math.sin(angle) * 10
elif mouse_x > 700 and mouse_x < 800 and mouse_y > 200 and mouse_y < 300:
# If the mouse is over an object, move the object towards the player
object_rect.centerx -= math.cos(angle) * 10
object_rect.centery -= math.sin(angle) * 10
def katana(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Randomly choose between the two attacks
attack_type = random.randint(1, 2)
# Load the katana image
try:
katana_surf = pygame.image.load('katana.png')
except pygame.error as e:
print(f"Cannot load katana image: {e}")
return
if attack_type == 1:
# Attack 1: Player moves/slashes in a random direction
angle = random.uniform(0, 2 * math.pi) # Random angle
slash_distance = 198 # Distance to move/slash
new_x = player_x + math.cos(angle) * slash_distance
new_y = player_y + math.sin(angle) * slash_distance
player_rect.center = (new_x, new_y)
# Draw the katana image on the player
katana_sprite = pygame.sprite.Sprite()
katana_sprite.image = katana_surf
katana_rect = katana_sprite.image.get_rect()
katana_rect.center = player_rect.center
screen.blit(katana_sprite.image, katana_rect)
else:
# Attack 2: Throw the katana towards the mouse position
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
katana_rect = katana_surf.get_rect()
katana_rect.center = player_rect.center
rotated_katana = pygame.transform.rotate(katana_surf, math.degrees(angle))
screen.blit(rotated_katana, katana_rect)
def bouncy_shoes(player_rect):
# Set a global variable to indicate that the player has bouncy shoes
global bouncy, player_jump_vel
bouncy = True
# Increase the player's jump velocity
player_jump_vel = 20
def key(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the distance between the mouse and the player
distance = ((mouse_x - player_x) ** 2 + (mouse_y - player_y) ** 2) ** 0.5
# Check if the mouse is over a door or a chest
if pygame.sprite.spritecollideany(mouse, doors) or pygame.sprite.spritecollideany(mouse, chests):
# If the mouse is over a door or a chest, unlock it and open it
pygame.sprite.spritecollide(mouse, doors, True)
pygame.sprite.spritecollide(mouse, chests, True)
# If the chest contains a tool, add it to the player's inventory
if chest.tool:
inventory.append(chest.tool)
def go_kart(player_rect):
# Set a global variable to indicate that the player is in a go kart
global go_kart
go_kart = True
# Increase the player's speed and size
player_speed = 15
player_rect.inflate_ip(50, 50)
# Load the image for the go kart
go_kart_image = pygame.image.load('go_kart.jpeg')
# Draw the go kart over the player
screen.blit(go_kart_image, player_rect)
# Check if the player collides with an enemy or a barrier
collided_enemies = pygame.sprite.spritecollide(player_sprite, enemies, True)
collided_barriers = pygame.sprite.spritecollide(player_sprite, barriers, True)
def freeze_ray(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the angle between the mouse and the player
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Create a line surface from the player to the mouse
line_length = math.hypot(mouse_x - player_x, mouse_y - player_y)
line = pygame.Surface((line_length, 5), pygame.SRCALPHA)
line.fill(BLUE)
line_rect = line.get_rect()
line_rect.center = player_rect.center
# Rotate the line surface
rotated_line = pygame.transform.rotate(line, math.degrees(angle))
# Draw the rotated line on the screen
screen.blit(rotated_line, (player_x, player_y))
# Create a temporary sprite for the line
line_sprite = pygame.sprite.Sprite()
line_sprite.image = rotated_line
line_sprite.rect = rotated_line.get_rect(center=line_rect.center)
# Check if the line intersects with an enemy or a platform
enemies_hit = pygame.sprite.spritecollide(line_sprite, enemies, False)
platforms_hit = pygame.sprite.spritecollide(line_sprite, platforms, False)
# Freeze the enemies and platforms that were hit
for enemy in enemies_hit:
freeze(enemy)
for platform in platforms_hit:
freeze(platform)
def freeze(sprite):
# Change the sprite's image to a frozen version
sprite.image = pygame.image.load(sprite.name + '_frozen.png')
# Set the sprite's frozen attribute to True
sprite.frozen = True
def tsunami_maker(player_rect):
global tsunami
tsunami = True
wave_surf = pygame.image.load('tsunami_maker.png')
# Resize the wave_surf to make it taller
wave_surf = pygame.transform.scale(wave_surf, (wave_surf.get_width(), wave_surf.get_height() * 3))
wave_sprite = pygame.sprite.Sprite()
wave_sprite.image = wave_surf
wave_sprite.rect = wave_sprite.image.get_rect()
wave_sprite.rect.bottomleft = (0, screen.get_height())
wave_speed = 10
while tsunami:
screen.blit(wave_sprite.image, wave_sprite.rect)
wave_sprite.rect.x += wave_speed
if wave_sprite.rect.right >= screen.get_width():
tsunami = False
pygame.display.flip()
def laser_beam(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the angle between the mouse and the player
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, YELLOW, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the line intersects with an enemy or a barrier
if pygame.sprite.spritecollideany(line, enemies) or pygame.sprite.spritecollideany(line, barriers):
# If the line intersects with an enemy or a barrier, destroy it
pygame.sprite.spritecollide(line, enemies, True)
pygame.sprite.spritecollide(line, barriers, True)
def speed_pill(player_rect):
# Set a global variable to indicate that the player has used the speed pill
global speed
speed = True
# Set a timer to make the player normal again after 10 seconds
pygame.time.set_timer(pygame.USEREVENT + 1, 10000)
# Increase the player's speed
player_speed = 10
def revival_kit(player_rect):
# Set a global variable to indicate that the player has a revival kit
global revival
revival = True
global player_health
# Check if the player's health is zero
if player_health == 0:
# If the player's health is zero, revive the player
player_health = 100
# Set the revival variable to False
revival = False
tool_functions = [invisibility_cloak, grappling_hook, katana, freeze_ray, bouncy_shoes, key,
go_kart, tsunami_maker, laser_beam, speed_pill, revival_kit]
def is_on_floor_or_stairs(player_rect):
"""
Check if the player is standing on a floor or stairs cell.
Returns True if standing on floor or stairs, False otherwise.
"""
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Check if the player is on the initial floor rows
if FLOOR_START_ROW <= player_rect.bottom // cell_height <= FLOOR_END_ROW:
for x in range(player_rect.left // cell_width, (player_rect.right + cell_width - 1) // cell_width):
if 0 <= x < GRID_WIDTH:
return True
return False
def draw_doors():
# Define the door's color
DOOR_COLOR = (139, 69, 19) # Saddle brown color
# Calculate the cell size based on the screen dimensions
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Draw door 1
door1_start_row = GRID_HEIGHT - 10
door1_end_row = GRID_HEIGHT - 13
door1_start_col = 10
door1_end_col = 11
for row in range(door1_start_row, door1_end_row - 1, -1):
for col in range(door1_start_col, door1_end_col + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, DOOR_COLOR, rect)
# Draw door 2
door2_start_row = GRID_HEIGHT - 3
door2_end_row = GRID_HEIGHT - 4
door2_start_col = 16
door2_end_col = 17
for row in range(door2_start_row, door2_end_row - 1, -1):
for col in range(door2_start_col, door2_end_col + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, DOOR_COLOR, rect)
def draw_floor():
# Define the floor's color
FLOOR_COLOR = (128, 64, 0) # Brown color
STAIRS_COLOR = (128, 128, 128) # Gray color
# Calculate the cell size based on the screen dimensions
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Draw the floor cells
for col in range(GRID_WIDTH):
for row in range(FLOOR_START_ROW, FLOOR_END_ROW + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, FLOOR_COLOR, rect)
enemies = pygame.sprite.Group()
barriers = pygame.sprite.Group()
platforms = pygame.sprite.Group()
doors = pygame.sprite.Group()
chests = pygame.sprite.Group()
gaps = pygame.sprite.Group()
tools = pygame.sprite.Group()
# Create some sprites and groups for the player
player_sprite = pygame.sprite.Sprite()
player_sprite.image = player_image
player_sprite.rect = player_sprite.image.get_rect()
player_sprite.rect.center = (100, 300)
# Create sprite groups
enemies = pygame.sprite.Group()
tools = pygame.sprite.Group() # Assuming tools are also Sprites
# Gravity constant
GRAVITY = 0.5
# Player properties
player_x = 100
player_y = 300
player_speed = 5
player_jump_vel = 10
player_vert_vel = 0 # Initial vertical velocity
player_health = 100
inventory = []
# Main game loop control
running = True
clock = pygame.time.Clock()
# Call show_intro() and get the button_assigned_functions list
button_assignments, button_assigned_functions = show_intro()
# Initialize player jumping state
player_is_jumping = False
# Create a rect for the player sprite
player_rect = player_sprite.rect
# In the main game loop
while running:
# ...
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
# Process KEYDOWN events individually
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE and not player_is_jumping:
# Start jumping
player_is_jumping = True
player_vert_vel = -player_jump_vel
if event.key == ord('v'): # Pressed V
try:
button_assigned_functions[0](player_sprite.rect) # Pass player_sprite.rect
except Exception as e:
print(f"Error calling tool function 1: {e}")
elif event.key == ord('b'): # Pressed B
try:
button_assigned_functions[1](player_sprite.rect) # Pass player_sprite.rect
except Exception as e:
print(f"Error calling tool function 2: {e}")
elif event.key == ord('n'): # Pressed N
try:
button_assigned_functions[2](player_sprite.rect) # Pass player_sprite.rect
except Exception as e:
print(f"Error calling tool function 3: {e}")
# 2. Update game state
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT]:
player_sprite.rect.x -= player_speed
if keys[pygame.K_RIGHT]:
player_sprite.rect.x += player_speed
if keys[pygame.K_UP]:
player_sprite.rect.y -= player_speed
if keys[pygame.K_DOWN]:
player_sprite.rect.y += player_speed
# Update player's vertical velocity and position if jumping
if player_is_jumping:
player_vert_vel += GRAVITY
player_sprite.rect.y += player_vert_vel
# Check if the player has landed on floor or stairs
if is_on_floor_or_stairs(player_sprite.rect):
player_is_jumping = False
player_vert_vel = 0
else:
# Apply gravity only if not on floor or stairs
if not is_on_floor_or_stairs(player_sprite.rect):
player_vert_vel += GRAVITY
player_sprite.rect.y += player_vert_vel
# Reset vertical velocity if on floor or stairs
if is_on_floor_or_stairs(player_sprite.rect):
player_vert_vel = 0
# Prevent the player from moving off screen
player_sprite.rect.clamp_ip(screen.get_rect())
# 3. Draw everything
screen.blit(background, (0, 0))
draw_floor()
draw_doors()
tools.draw(screen)
enemies.draw(screen)
screen.blit(player_sprite.image, player_sprite.rect) # Draw player
# Check if the player is invisible
if invisible:
# Get the updated player position
player_x, player_y = player_sprite.rect.topleft
# Draw the invisibility cloak image over the player
screen.blit(invisibility_cloak_image, (player_x, player_y))
# After drawing everything, update/flip the display
pygame.display.flip()
# 4. Cap the frame rate
clock.tick(60)
if __name__ == "__main__":
main() when katana is pressed in game cannot see it and the player should know which of the 2 attacks is happeing
|
8a912f98670a4bfd5abd60a8b4263568
|
{
"intermediate": 0.2879960834980011,
"beginner": 0.45061373710632324,
"expert": 0.26139017939567566
}
|
44,437
|
import pygame
import random
import math
# Initialize pygame and create a screen object
pygame.init()
screen = pygame.display.set_mode((1000, 800))
# Define colors
BLACK = (0, 0, 0)
RED = (255, 0, 0)
YELLOW = (255, 255, 0)
BLUE = (0, 0, 255)
# Define grid size
GRID_WIDTH = 21
GRID_HEIGHT = 17
# Initialize the invisible variable
invisible = False
# Define initial floor position
FLOOR_START_ROW = GRID_HEIGHT - 2
FLOOR_END_ROW = GRID_HEIGHT - 1
pygame.display.set_caption('100% no luck')
# Load the images for the background, the player, and the boss
# Ensure that these images are present in your project directory
try:
background = pygame.image.load('level_1_background.jpeg')
player_image = pygame.image.load('player1_back.png')
invisibility_cloak_image = pygame.image.load('invisibility_cloak.png')
grappling_hook_image = pygame.image.load('grappling_hook.png')
katana_image = pygame.image.load('katana.png')
freezing_ray_image = pygame.image.load('freezing_ray.png')
speed_pill_image = pygame.image.load('speed_pill.jpeg')
bouncy_shoes_image = pygame.image.load('bouncy_shoes.png')
key_image = pygame.image.load('key.png')
tsunami_maker_image = pygame.image.load('tsunami_maker.png')
laser_beam_image = pygame.image.load('laser_beam.png')
go_kart_image = pygame.image.load('go_kart.jpeg')
revival_kit_image = pygame.image.load('revival_kit.jpeg')
except pygame.error as e:
print("Cannot load images:", e)
raise SystemExit
# Define the colors for the text
WHITE = (255, 255, 255)
# Define the font for the text
font = pygame.font.SysFont('Arial', 32)
# Define the text for the intro and the tools
intro_text = "Welcome to 100% no luck, a game where you have to use smart logic and some luck to beat the dungeon. You will spawn with 3 tools out of a possible 15 tools randomized. Each tool has a different effect and can help you or hinder you depending on the situation. You have to think carefully about how to use your tools and when to use them. The dungeon has many obstacles and enemies that you have to overcome. The goal is to reach the end of the dungeon and defeat the boss. Good luck!"
tools_text = ["Invisibility cloak: Makes you invisible for 10 seconds. Useful for sneaking past enemies or traps.",
"Grappling hook: Allows you to swing across gaps or pull objects towards you.",
"Katana: A sharp sword that can cut through anything. Useful for fighting enemies or breaking barriers.",
"Freeze ray: A device that can freeze anything in its path. Useful for stopping enemies or creating platforms.",
"Bouncy shoes: Shoes that make you jump higher and farther. Useful for reaching high places or avoiding obstacles.",
"Key: A key that can unlock any door or chest. Useful for accessing hidden areas or treasures.",
"Go kart: A vehicle that can move fast and run over anything. Useful for escaping enemies or crossing large distances.",
"Tsunami maker: A device that can create a huge wave of water. Useful for washing away enemies or filling gaps.",
"Laser beam: A device that can shoot a powerful laser. Useful for destroying enemies or barriers.",
"Speed pill: A pill that can make you move faster for 10 seconds. Useful for dodging enemies or traps.",
"Revival kit: A kit that can revive you once if you die. Useful for surviving fatal situations."]
def show_intro():
intro_text = "Welcome to 100% no luck, a game where you have to use smart logic and some luck to beat the dungeon. You will spawn with 3 tools out of a possible 15 tools randomized. Each tool has a different effect and can help you or hinder you depending on the situation. You have to think carefully about how to use your tools and when to use them. The dungeon has many obstacles and enemies that you have to overcome. The goal is to reach the end of the dungeon and defeat the boss. Good luck!"
# Wrap the intro text
intro_lines = []
max_width = 950 # Adjust as needed
words = intro_text.split()
current_line = words[0]
for word in words[1:]:
if font.size(current_line + ' ' + word)[0] < max_width:
current_line += ' ' + word
else:
intro_lines.append(current_line)
current_line = word
intro_lines.append(current_line)
current_line = 0
intro_complete = False
start_time = pygame.time.get_ticks()
while not intro_complete:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
screen.fill((0, 0, 0))
intro_surface = font.render(intro_lines[current_line], True, WHITE)
intro_rect = intro_surface.get_rect(center=(screen.get_width() // 2, screen.get_height() // 2))
screen.blit(intro_surface, intro_rect)
if pygame.time.get_ticks() - start_time > 2980:
current_line += 1
start_time = pygame.time.get_ticks()
if current_line == len(intro_lines):
intro_complete = True
pygame.display.flip()
pygame.time.Clock().tick(60)
screen.fill((0, 0, 0))
pygame.display.flip()
tools_title_surface = font.render("Selected Tools:", True, WHITE)
tools_title_rect = tools_title_surface.get_rect(center=(screen.get_width() // 2, 100))
screen.blit(tools_title_surface, tools_title_rect)
pygame.display.flip()
pygame.time.delay(1000)
available_buttons = ['v', 'b', 'n', 'x', 'y', 'z'] # Add more buttons if needed
selected_tools = random.sample(tools_text, 3)
# Assign buttons to the selected tools
button_assignments = available_buttons[:3] # Take the first three buttons
button_assigned_functions = [tool_functions[tools_text.index(tool)] for tool in selected_tools]
# Wrap the tool descriptions and display them with their assigned buttons
wrapped_tools = []
for i, tool_desc in enumerate(selected_tools):
tool_lines = []
current_line = f"{button_assignments[i]}: {tool_desc.split()[0]}"
for word in tool_desc.split()[1:]:
if font.size(current_line + ' ' + word)[0] < max_width:
current_line += ' ' + word
else:
tool_lines.append(current_line)
current_line = word
tool_lines.append(current_line)
wrapped_tools.append(tool_lines)
selected_tools_surface = [font.render(line, True, WHITE) for tool_lines in wrapped_tools for line in tool_lines]
for i, tool_surface in enumerate(selected_tools_surface):
tool_rect = tool_surface.get_rect(center=(screen.get_width() // 2, 200 + i * 50))
screen.blit(tool_surface, tool_rect)
pygame.display.flip()
start_time = pygame.time.get_ticks()
while pygame.time.get_ticks() - start_time < 2000:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
screen.fill((0, 0, 0))
pygame.display.flip()
return button_assignments, button_assigned_functions
# Define the logic for each tool as a function
def invisibility_cloak(player_rect):
# Set a global variable to indicate that the player is invisible
global invisible
invisible = True
# Set a timer to make the player visible again after 10 seconds
pygame.time.set_timer(pygame.USEREVENT, 10000)
# Create a Rect for the invisibility cloak sprite
cloak_rect = player_rect.copy()
cloak_rect.inflate_ip(50, 50)
# Load the invisibility cloak image
try:
cloak_surf = pygame.image.load('invisibility_cloak.png')
except pygame.error as e:
print(f"Cannot load invisibility cloak image: {e}")
return
while invisible:
# Draw the invisibility cloak sprite over the player
screen.blit(cloak_surf, cloak_rect)
# Update the cloak position based on the player's position
cloak_rect.center = player_rect.center
# Check for events
for event in pygame.event.get():
if event.type == pygame.USEREVENT:
# Stop the invisibility cloak effect
invisible = False
# Update the display
pygame.display.flip()
# Limit the frame rate
pygame.time.Clock().tick(60)
# Reset the invisible state
invisible = False
def grappling_hook(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the distance and the angle between the mouse and the player
distance = ((mouse_x - player_x) ** 2 + (mouse_y - player_y) ** 2) ** 0.5
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, BLACK, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the mouse is over a gap or an object
if mouse_x > 600 and mouse_x < 700 and mouse_y > 300 and mouse_y < 400:
# If the mouse is over a gap, move the player towards the mouse
player_rect.centerx += math.cos(angle) * 10
player_rect.centery += math.sin(angle) * 10
elif mouse_x > 700 and mouse_x < 800 and mouse_y > 200 and mouse_y < 300:
# If the mouse is over an object, move the object towards the player
object_rect.centerx -= math.cos(angle) * 10
object_rect.centery -= math.sin(angle) * 10
def katana(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Randomly choose between the two attacks
attack_type = random.randint(1, 2)
# Load the katana image
try:
katana_surf = pygame.image.load('katana.png')
except pygame.error as e:
print(f"Cannot load katana image: {e}")
return
# Create a temporary sprite for the katana
katana_sprite = pygame.sprite.Sprite()
katana_sprite.image = katana_surf
katana_sprite.rect = katana_sprite.image.get_rect()
katana_sprite.rect.center = player_rect.center
if attack_type == 1:
# Attack 1: Player moves/slashes in a random direction
angle = random.uniform(0, 2 * math.pi) # Random angle
slash_distance = 198 # Distance to move/slash
new_x = player_x + math.cos(angle) * slash_distance
new_y = player_y + math.sin(angle) * slash_distance
player_rect.center = (new_x, new_y)
# Draw the katana image on the player
katana_sprite.rect.center = player_rect.center
screen.blit(katana_sprite.image, katana_sprite.rect)
else:
# Attack 2: Throw the katana towards the mouse position
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
katana_sprite.image = pygame.transform.rotate(katana_sprite.image, math.degrees(angle))
katana_sprite.rect = katana_sprite.image.get_rect()
katana_sprite.rect.center = (player_x, player_y)
screen.blit(katana_sprite.image, katana_sprite.rect)
# Move the katana towards the mouse position
dx = mouse_x - player_x
dy = mouse_y - player_y
distance = (dx ** 2 + dy ** 2) ** 0.5
katana_speed = 10
katana_sprite.rect.x += dx / distance * katana_speed
katana_sprite.rect.y += dy / distance * katana_speed
# Check if the katana has reached the mouse position
if katana_sprite.rect.collidepoint(mouse_x, mouse_y):
# Reset the katana position
katana_sprite.rect.center = player_rect.center
def bouncy_shoes(player_rect):
# Set a global variable to indicate that the player has bouncy shoes
global bouncy, player_jump_vel
bouncy = True
# Increase the player's jump velocity
player_jump_vel = 20
def key(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the distance between the mouse and the player
distance = ((mouse_x - player_x) ** 2 + (mouse_y - player_y) ** 2) ** 0.5
# Check if the mouse is over a door or a chest
if pygame.sprite.spritecollideany(mouse, doors) or pygame.sprite.spritecollideany(mouse, chests):
# If the mouse is over a door or a chest, unlock it and open it
pygame.sprite.spritecollide(mouse, doors, True)
pygame.sprite.spritecollide(mouse, chests, True)
# If the chest contains a tool, add it to the player's inventory
if chest.tool:
inventory.append(chest.tool)
def go_kart(player_rect):
# Set a global variable to indicate that the player is in a go kart
global go_kart
go_kart = True
# Increase the player's speed and size
player_speed = 15
player_rect.inflate_ip(50, 50)
# Load the image for the go kart
go_kart_image = pygame.image.load('go_kart.jpeg')
# Draw the go kart over the player
screen.blit(go_kart_image, player_rect)
# Check if the player collides with an enemy or a barrier
collided_enemies = pygame.sprite.spritecollide(player_sprite, enemies, True)
collided_barriers = pygame.sprite.spritecollide(player_sprite, barriers, True)
def freeze_ray(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the angle between the mouse and the player
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Create a line surface from the player to the mouse
line_length = math.hypot(mouse_x - player_x, mouse_y - player_y)
line = pygame.Surface((line_length, 5), pygame.SRCALPHA)
line.fill(BLUE)
line_rect = line.get_rect()
line_rect.center = player_rect.center
# Rotate the line surface
rotated_line = pygame.transform.rotate(line, math.degrees(angle))
# Draw the rotated line on the screen
screen.blit(rotated_line, (player_x, player_y))
# Create a temporary sprite for the line
line_sprite = pygame.sprite.Sprite()
line_sprite.image = rotated_line
line_sprite.rect = rotated_line.get_rect(center=line_rect.center)
# Check if the line intersects with an enemy or a platform
enemies_hit = pygame.sprite.spritecollide(line_sprite, enemies, False)
platforms_hit = pygame.sprite.spritecollide(line_sprite, platforms, False)
# Freeze the enemies and platforms that were hit
for enemy in enemies_hit:
freeze(enemy)
for platform in platforms_hit:
freeze(platform)
def freeze(sprite):
# Change the sprite's image to a frozen version
sprite.image = pygame.image.load(sprite.name + '_frozen.png')
# Set the sprite's frozen attribute to True
sprite.frozen = True
def tsunami_maker(player_rect):
global tsunami
tsunami = True
wave_surf = pygame.image.load('tsunami_maker.png')
# Resize the wave_surf to make it taller
wave_surf = pygame.transform.scale(wave_surf, (wave_surf.get_width(), wave_surf.get_height() * 3))
wave_sprite = pygame.sprite.Sprite()
wave_sprite.image = wave_surf
wave_sprite.rect = wave_sprite.image.get_rect()
wave_sprite.rect.bottomleft = (0, screen.get_height())
wave_speed = 10
while tsunami:
screen.blit(wave_sprite.image, wave_sprite.rect)
wave_sprite.rect.x += wave_speed
if wave_sprite.rect.right >= screen.get_width():
tsunami = False
pygame.display.flip()
def laser_beam(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the angle between the mouse and the player
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, YELLOW, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the line intersects with an enemy or a barrier
if pygame.sprite.spritecollideany(line, enemies) or pygame.sprite.spritecollideany(line, barriers):
# If the line intersects with an enemy or a barrier, destroy it
pygame.sprite.spritecollide(line, enemies, True)
pygame.sprite.spritecollide(line, barriers, True)
def speed_pill(player_rect):
# Set a global variable to indicate that the player has used the speed pill
global speed
speed = True
# Set a timer to make the player normal again after 10 seconds
pygame.time.set_timer(pygame.USEREVENT + 1, 10000)
# Increase the player's speed
player_speed = 10
def revival_kit(player_rect):
# Set a global variable to indicate that the player has a revival kit
global revival
revival = True
global player_health
# Check if the player's health is zero
if player_health == 0:
# If the player's health is zero, revive the player
player_health = 100
# Set the revival variable to False
revival = False
tool_functions = [invisibility_cloak, grappling_hook, katana, freeze_ray, bouncy_shoes, key,
go_kart, tsunami_maker, laser_beam, speed_pill, revival_kit]
def is_on_floor_or_stairs(player_rect):
"""
Check if the player is standing on a floor or stairs cell.
Returns True if standing on floor or stairs, False otherwise.
"""
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Check if the player is on the initial floor rows
if FLOOR_START_ROW <= player_rect.bottom // cell_height <= FLOOR_END_ROW:
for x in range(player_rect.left // cell_width, (player_rect.right + cell_width - 1) // cell_width):
if 0 <= x < GRID_WIDTH:
return True
return False
def draw_doors():
# Define the door's color
DOOR_COLOR = (139, 69, 19) # Saddle brown color
# Calculate the cell size based on the screen dimensions
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Draw door 1
door1_start_row = GRID_HEIGHT - 10
door1_end_row = GRID_HEIGHT - 13
door1_start_col = 10
door1_end_col = 11
for row in range(door1_start_row, door1_end_row - 1, -1):
for col in range(door1_start_col, door1_end_col + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, DOOR_COLOR, rect)
# Draw door 2
door2_start_row = GRID_HEIGHT - 3
door2_end_row = GRID_HEIGHT - 4
door2_start_col = 16
door2_end_col = 17
for row in range(door2_start_row, door2_end_row - 1, -1):
for col in range(door2_start_col, door2_end_col + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, DOOR_COLOR, rect)
def draw_floor():
# Define the floor's color
FLOOR_COLOR = (128, 64, 0) # Brown color
STAIRS_COLOR = (128, 128, 128) # Gray color
# Calculate the cell size based on the screen dimensions
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Draw the floor cells
for col in range(GRID_WIDTH):
for row in range(FLOOR_START_ROW, FLOOR_END_ROW + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, FLOOR_COLOR, rect)
enemies = pygame.sprite.Group()
barriers = pygame.sprite.Group()
platforms = pygame.sprite.Group()
doors = pygame.sprite.Group()
chests = pygame.sprite.Group()
gaps = pygame.sprite.Group()
tools = pygame.sprite.Group()
# Create some sprites and groups for the player
player_sprite = pygame.sprite.Sprite()
player_sprite.image = player_image
player_sprite.rect = player_sprite.image.get_rect()
player_sprite.rect.center = (100, 300)
# Create sprite groups
enemies = pygame.sprite.Group()
tools = pygame.sprite.Group() # Assuming tools are also Sprites
# Gravity constant
GRAVITY = 0.5
# Player properties
player_x = 100
player_y = 300
player_speed = 5
player_jump_vel = 10
player_vert_vel = 0 # Initial vertical velocity
player_health = 100
inventory = []
# Main game loop control
running = True
clock = pygame.time.Clock()
# Call show_intro() and get the button_assigned_functions list
button_assignments, button_assigned_functions = show_intro()
# Initialize player jumping state
player_is_jumping = False
# Create a rect for the player sprite
player_rect = player_sprite.rect
# In the main game loop
while running:
# ...
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
# Process KEYDOWN events individually
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE and not player_is_jumping:
# Start jumping
player_is_jumping = True
player_vert_vel = -player_jump_vel
if event.key == ord('v'): # Pressed V
try:
button_assigned_functions[0](player_sprite.rect) # Pass player_sprite.rect
except Exception as e:
print(f"Error calling tool function 1: {e}")
elif event.key == ord('b'): # Pressed B
try:
button_assigned_functions[1](player_sprite.rect) # Pass player_sprite.rect
except Exception as e:
print(f"Error calling tool function 2: {e}")
elif event.key == ord('n'): # Pressed N
try:
button_assigned_functions[2](player_sprite.rect) # Pass player_sprite.rect
except Exception as e:
print(f"Error calling tool function 3: {e}")
# 2. Update game state
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT]:
player_sprite.rect.x -= player_speed
if keys[pygame.K_RIGHT]:
player_sprite.rect.x += player_speed
if keys[pygame.K_UP]:
player_sprite.rect.y -= player_speed
if keys[pygame.K_DOWN]:
player_sprite.rect.y += player_speed
# Update player's vertical velocity and position if jumping
if player_is_jumping:
player_vert_vel += GRAVITY
player_sprite.rect.y += player_vert_vel
# Check if the player has landed on floor or stairs
if is_on_floor_or_stairs(player_sprite.rect):
player_is_jumping = False
player_vert_vel = 0
else:
# Apply gravity only if not on floor or stairs
if not is_on_floor_or_stairs(player_sprite.rect):
player_vert_vel += GRAVITY
player_sprite.rect.y += player_vert_vel
# Reset vertical velocity if on floor or stairs
if is_on_floor_or_stairs(player_sprite.rect):
player_vert_vel = 0
# Prevent the player from moving off screen
player_sprite.rect.clamp_ip(screen.get_rect())
# 3. Draw everything
screen.blit(background, (0, 0))
draw_floor()
draw_doors()
tools.draw(screen)
enemies.draw(screen)
screen.blit(player_sprite.image, player_sprite.rect) # Draw player
# Check if the player is invisible
if invisible:
# Get the updated player position
player_x, player_y = player_sprite.rect.topleft
# Draw the invisibility cloak image over the player
screen.blit(invisibility_cloak_image, (player_x, player_y))
# After drawing everything, update/flip the display
pygame.display.flip()
# 4. Cap the frame rate
clock.tick(60)
if __name__ == "__main__":
main() now code to beat the level the player has to reach enter either door, to enter door 1 player just has to reach it because its open but for door 2 its locked so player needs to have the key.
|
f2641d10fc44eca61eaf41928e6bb3b9
|
{
"intermediate": 0.2879960834980011,
"beginner": 0.45061373710632324,
"expert": 0.26139017939567566
}
|
44,438
|
import pygame
import random
import math
# Initialize pygame and create a screen object
pygame.init()
screen = pygame.display.set_mode((1000, 800))
# Define colors
BLACK = (0, 0, 0)
RED = (255, 0, 0)
YELLOW = (255, 255, 0)
BLUE = (0, 0, 255)
# Define grid size
GRID_WIDTH = 21
GRID_HEIGHT = 17
# Initialize the invisible variable
invisible = False
# Define initial floor position
FLOOR_START_ROW = GRID_HEIGHT - 2
FLOOR_END_ROW = GRID_HEIGHT - 1
pygame.display.set_caption('100% no luck')
# Load the images for the background, the player, and the boss
# Ensure that these images are present in your project directory
try:
background = pygame.image.load('level_1_background.jpeg')
player_image = pygame.image.load('player1_back.png')
invisibility_cloak_image = pygame.image.load('invisibility_cloak.png')
grappling_hook_image = pygame.image.load('grappling_hook.png')
katana_image = pygame.image.load('katana.png')
freezing_ray_image = pygame.image.load('freezing_ray.png')
speed_pill_image = pygame.image.load('speed_pill.jpeg')
bouncy_shoes_image = pygame.image.load('bouncy_shoes.png')
key_image = pygame.image.load('key.png')
tsunami_maker_image = pygame.image.load('tsunami_maker.png')
laser_beam_image = pygame.image.load('laser_beam.png')
go_kart_image = pygame.image.load('go_kart.jpeg')
revival_kit_image = pygame.image.load('revival_kit.jpeg')
except pygame.error as e:
print("Cannot load images:", e)
raise SystemExit
# Define the colors for the text
WHITE = (255, 255, 255)
# Define the font for the text
font = pygame.font.SysFont('Arial', 32)
# Define the text for the intro and the tools
intro_text = "Welcome to 100% no luck, a game where you have to use smart logic and some luck to beat the dungeon. You will spawn with 3 tools out of a possible 15 tools randomized. Each tool has a different effect and can help you or hinder you depending on the situation. You have to think carefully about how to use your tools and when to use them. The dungeon has many obstacles and enemies that you have to overcome. The goal is to reach the end of the dungeon and defeat the boss. Good luck!"
tools_text = ["Invisibility cloak: Makes you invisible for 10 seconds. Useful for sneaking past enemies or traps.",
"Grappling hook: Allows you to swing across gaps or pull objects towards you.",
"Katana: A sharp sword that can cut through anything. Useful for fighting enemies or breaking barriers.",
"Freeze ray: A device that can freeze anything in its path. Useful for stopping enemies or creating platforms.",
"Bouncy shoes: Shoes that make you jump higher and farther. Useful for reaching high places or avoiding obstacles.",
"Key: A key that can unlock any door or chest. Useful for accessing hidden areas or treasures.",
"Go kart: A vehicle that can move fast and run over anything. Useful for escaping enemies or crossing large distances.",
"Tsunami maker: A device that can create a huge wave of water. Useful for washing away enemies or filling gaps.",
"Laser beam: A device that can shoot a powerful laser. Useful for destroying enemies or barriers.",
"Speed pill: A pill that can make you move faster for 10 seconds. Useful for dodging enemies or traps.",
"Revival kit: A kit that can revive you once if you die. Useful for surviving fatal situations."]
def show_intro():
intro_text = "Welcome to 100% no luck, a game where you have to use smart logic and some luck to beat the dungeon. You will spawn with 3 tools out of a possible 15 tools randomized. Each tool has a different effect and can help you or hinder you depending on the situation. You have to think carefully about how to use your tools and when to use them. The dungeon has many obstacles and enemies that you have to overcome. The goal is to reach the end of the dungeon and defeat the boss. Good luck!"
# Wrap the intro text
intro_lines = []
max_width = 950 # Adjust as needed
words = intro_text.split()
current_line = words[0]
for word in words[1:]:
if font.size(current_line + ' ' + word)[0] < max_width:
current_line += ' ' + word
else:
intro_lines.append(current_line)
current_line = word
intro_lines.append(current_line)
current_line = 0
intro_complete = False
start_time = pygame.time.get_ticks()
while not intro_complete:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
screen.fill((0, 0, 0))
intro_surface = font.render(intro_lines[current_line], True, WHITE)
intro_rect = intro_surface.get_rect(center=(screen.get_width() // 2, screen.get_height() // 2))
screen.blit(intro_surface, intro_rect)
if pygame.time.get_ticks() - start_time > 2980:
current_line += 1
start_time = pygame.time.get_ticks()
if current_line == len(intro_lines):
intro_complete = True
pygame.display.flip()
pygame.time.Clock().tick(60)
screen.fill((0, 0, 0))
pygame.display.flip()
tools_title_surface = font.render("Selected Tools:", True, WHITE)
tools_title_rect = tools_title_surface.get_rect(center=(screen.get_width() // 2, 100))
screen.blit(tools_title_surface, tools_title_rect)
pygame.display.flip()
pygame.time.delay(1000)
available_buttons = ['v', 'b', 'n', 'x', 'y', 'z'] # Add more buttons if needed
selected_tools = random.sample(tools_text, 3)
# Assign buttons to the selected tools
button_assignments = available_buttons[:3] # Take the first three buttons
button_assigned_functions = [tool_functions[tools_text.index(tool)] for tool in selected_tools]
# Wrap the tool descriptions and display them with their assigned buttons
wrapped_tools = []
for i, tool_desc in enumerate(selected_tools):
tool_lines = []
current_line = f"{button_assignments[i]}: {tool_desc.split()[0]}"
for word in tool_desc.split()[1:]:
if font.size(current_line + ' ' + word)[0] < max_width:
current_line += ' ' + word
else:
tool_lines.append(current_line)
current_line = word
tool_lines.append(current_line)
wrapped_tools.append(tool_lines)
selected_tools_surface = [font.render(line, True, WHITE) for tool_lines in wrapped_tools for line in tool_lines]
for i, tool_surface in enumerate(selected_tools_surface):
tool_rect = tool_surface.get_rect(center=(screen.get_width() // 2, 200 + i * 50))
screen.blit(tool_surface, tool_rect)
pygame.display.flip()
start_time = pygame.time.get_ticks()
while pygame.time.get_ticks() - start_time < 2000:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
screen.fill((0, 0, 0))
pygame.display.flip()
return button_assignments, button_assigned_functions
# Define the logic for each tool as a function
def invisibility_cloak(player_rect):
# Set a global variable to indicate that the player is invisible
global invisible
invisible = True
# Set a timer to make the player visible again after 10 seconds
pygame.time.set_timer(pygame.USEREVENT, 10000)
# Create a Rect for the invisibility cloak sprite
cloak_rect = player_rect.copy()
cloak_rect.inflate_ip(50, 50)
# Load the invisibility cloak image
try:
cloak_surf = pygame.image.load('invisibility_cloak.png')
except pygame.error as e:
print(f"Cannot load invisibility cloak image: {e}")
return
while invisible:
# Draw the invisibility cloak sprite over the player
screen.blit(cloak_surf, cloak_rect)
# Update the cloak position based on the player's position
cloak_rect.center = player_rect.center
# Check for events
for event in pygame.event.get():
if event.type == pygame.USEREVENT:
# Stop the invisibility cloak effect
invisible = False
# Update the display
pygame.display.flip()
# Limit the frame rate
pygame.time.Clock().tick(60)
# Reset the invisible state
invisible = False
def grappling_hook(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the distance and the angle between the mouse and the player
distance = ((mouse_x - player_x) ** 2 + (mouse_y - player_y) ** 2) ** 0.5
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, BLACK, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the mouse is over a gap or an object
if mouse_x > 600 and mouse_x < 700 and mouse_y > 300 and mouse_y < 400:
# If the mouse is over a gap, move the player towards the mouse
player_rect.centerx += math.cos(angle) * 10
player_rect.centery += math.sin(angle) * 10
elif mouse_x > 700 and mouse_x < 800 and mouse_y > 200 and mouse_y < 300:
# If the mouse is over an object, move the object towards the player
object_rect.centerx -= math.cos(angle) * 10
object_rect.centery -= math.sin(angle) * 10
def katana(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Randomly choose between the two attacks
attack_type = random.randint(1, 2)
# Load the katana image
try:
katana_surf = pygame.image.load('katana.png')
except pygame.error as e:
print(f"Cannot load katana image: {e}")
return
# Create a temporary sprite for the katana
katana_sprite = pygame.sprite.Sprite()
katana_sprite.image = katana_surf
katana_sprite.rect = katana_sprite.image.get_rect()
katana_sprite.rect.center = player_rect.center
if attack_type == 1:
# Attack 1: Player moves/slashes in a random direction
angle = random.uniform(0, 2 * math.pi) # Random angle
slash_distance = 198 # Distance to move/slash
new_x = player_x + math.cos(angle) * slash_distance
new_y = player_y + math.sin(angle) * slash_distance
player_rect.center = (new_x, new_y)
# Draw the katana image on the player
katana_sprite.rect.center = player_rect.center
screen.blit(katana_sprite.image, katana_sprite.rect)
else:
# Attack 2: Throw the katana towards the mouse position
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
katana_sprite.image = pygame.transform.rotate(katana_sprite.image, math.degrees(angle))
katana_sprite.rect = katana_sprite.image.get_rect()
katana_sprite.rect.center = (player_x, player_y)
screen.blit(katana_sprite.image, katana_sprite.rect)
# Move the katana towards the mouse position
dx = mouse_x - player_x
dy = mouse_y - player_y
distance = (dx ** 2 + dy ** 2) ** 0.5
katana_speed = 10
katana_sprite.rect.x += dx / distance * katana_speed
katana_sprite.rect.y += dy / distance * katana_speed
# Check if the katana has reached the mouse position
if katana_sprite.rect.collidepoint(mouse_x, mouse_y):
# Reset the katana position
katana_sprite.rect.center = player_rect.center
def bouncy_shoes(player_rect):
# Set a global variable to indicate that the player has bouncy shoes
global bouncy, player_jump_vel
bouncy = True
# Increase the player's jump velocity
player_jump_vel = 20
def key(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the distance between the mouse and the player
distance = ((mouse_x - player_x) ** 2 + (mouse_y - player_y) ** 2) ** 0.5
# Check if the mouse is over a door or a chest
if pygame.sprite.spritecollideany(mouse, doors) or pygame.sprite.spritecollideany(mouse, chests):
# If the mouse is over a door or a chest, unlock it and open it
pygame.sprite.spritecollide(mouse, doors, True)
pygame.sprite.spritecollide(mouse, chests, True)
# If the chest contains a tool, add it to the player's inventory
if chest.tool:
inventory.append(chest.tool)
def go_kart(player_rect):
# Set a global variable to indicate that the player is in a go kart
global go_kart
go_kart = True
# Increase the player's speed and size
player_speed = 15
player_rect.inflate_ip(50, 50)
# Load the image for the go kart
go_kart_image = pygame.image.load('go_kart.jpeg')
# Draw the go kart over the player
screen.blit(go_kart_image, player_rect)
# Check if the player collides with an enemy or a barrier
collided_enemies = pygame.sprite.spritecollide(player_sprite, enemies, True)
collided_barriers = pygame.sprite.spritecollide(player_sprite, barriers, True)
def freeze_ray(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the angle between the mouse and the player
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Create a line surface from the player to the mouse
line_length = math.hypot(mouse_x - player_x, mouse_y - player_y)
line = pygame.Surface((line_length, 5), pygame.SRCALPHA)
line.fill(BLUE)
line_rect = line.get_rect()
line_rect.center = player_rect.center
# Rotate the line surface
rotated_line = pygame.transform.rotate(line, math.degrees(angle))
# Draw the rotated line on the screen
screen.blit(rotated_line, (player_x, player_y))
# Create a temporary sprite for the line
line_sprite = pygame.sprite.Sprite()
line_sprite.image = rotated_line
line_sprite.rect = rotated_line.get_rect(center=line_rect.center)
# Check if the line intersects with an enemy or a platform
enemies_hit = pygame.sprite.spritecollide(line_sprite, enemies, False)
platforms_hit = pygame.sprite.spritecollide(line_sprite, platforms, False)
# Freeze the enemies and platforms that were hit
for enemy in enemies_hit:
freeze(enemy)
for platform in platforms_hit:
freeze(platform)
def freeze(sprite):
# Change the sprite's image to a frozen version
sprite.image = pygame.image.load(sprite.name + '_frozen.png')
# Set the sprite's frozen attribute to True
sprite.frozen = True
def tsunami_maker(player_rect):
global tsunami
tsunami = True
wave_surf = pygame.image.load('tsunami_maker.png')
# Resize the wave_surf to make it taller
wave_surf = pygame.transform.scale(wave_surf, (wave_surf.get_width(), wave_surf.get_height() * 3))
wave_sprite = pygame.sprite.Sprite()
wave_sprite.image = wave_surf
wave_sprite.rect = wave_sprite.image.get_rect()
wave_sprite.rect.bottomleft = (0, screen.get_height())
wave_speed = 10
while tsunami:
screen.blit(wave_sprite.image, wave_sprite.rect)
wave_sprite.rect.x += wave_speed
if wave_sprite.rect.right >= screen.get_width():
tsunami = False
pygame.display.flip()
def laser_beam(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the angle between the mouse and the player
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, YELLOW, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the line intersects with an enemy or a barrier
if pygame.sprite.spritecollideany(line, enemies) or pygame.sprite.spritecollideany(line, barriers):
# If the line intersects with an enemy or a barrier, destroy it
pygame.sprite.spritecollide(line, enemies, True)
pygame.sprite.spritecollide(line, barriers, True)
def speed_pill(player_rect):
# Set a global variable to indicate that the player has used the speed pill
global speed
speed = True
# Set a timer to make the player normal again after 10 seconds
pygame.time.set_timer(pygame.USEREVENT + 1, 10000)
# Increase the player's speed
player_speed = 10
def revival_kit(player_rect):
# Set a global variable to indicate that the player has a revival kit
global revival
revival = True
global player_health
# Check if the player's health is zero
if player_health == 0:
# If the player's health is zero, revive the player
player_health = 100
# Set the revival variable to False
revival = False
tool_functions = [invisibility_cloak, grappling_hook, katana, freeze_ray, bouncy_shoes, key,
go_kart, tsunami_maker, laser_beam, speed_pill, revival_kit]
def is_on_floor_or_stairs(player_rect):
"""
Check if the player is standing on a floor or stairs cell.
Returns True if standing on floor or stairs, False otherwise.
"""
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Check if the player is on the initial floor rows
if FLOOR_START_ROW <= player_rect.bottom // cell_height <= FLOOR_END_ROW:
for x in range(player_rect.left // cell_width, (player_rect.right + cell_width - 1) // cell_width):
if 0 <= x < GRID_WIDTH:
return True
return False
def draw_doors():
# Define the door's color
DOOR_COLOR = (139, 69, 19) # Saddle brown color
# Calculate the cell size based on the screen dimensions
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Draw door 1
door1_start_row = GRID_HEIGHT - 10
door1_end_row = GRID_HEIGHT - 13
door1_start_col = 10
door1_end_col = 11
for row in range(door1_start_row, door1_end_row - 1, -1):
for col in range(door1_start_col, door1_end_col + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, DOOR_COLOR, rect)
# Draw door 2
door2_start_row = GRID_HEIGHT - 3
door2_end_row = GRID_HEIGHT - 4
door2_start_col = 16
door2_end_col = 17
for row in range(door2_start_row, door2_end_row - 1, -1):
for col in range(door2_start_col, door2_end_col + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, DOOR_COLOR, rect)
def draw_floor():
# Define the floor's color
FLOOR_COLOR = (128, 64, 0) # Brown color
STAIRS_COLOR = (128, 128, 128) # Gray color
# Calculate the cell size based on the screen dimensions
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Draw the floor cells
for col in range(GRID_WIDTH):
for row in range(FLOOR_START_ROW, FLOOR_END_ROW + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, FLOOR_COLOR, rect)
enemies = pygame.sprite.Group()
barriers = pygame.sprite.Group()
platforms = pygame.sprite.Group()
doors = pygame.sprite.Group()
chests = pygame.sprite.Group()
gaps = pygame.sprite.Group()
tools = pygame.sprite.Group()
# Create some sprites and groups for the player
player_sprite = pygame.sprite.Sprite()
player_sprite.image = player_image
player_sprite.rect = player_sprite.image.get_rect()
player_sprite.rect.center = (100, 300)
# Create sprite groups
enemies = pygame.sprite.Group()
tools = pygame.sprite.Group() # Assuming tools are also Sprites
# Gravity constant
GRAVITY = 0.5
# Player properties
player_x = 100
player_y = 300
player_speed = 5
player_jump_vel = 10
player_vert_vel = 0 # Initial vertical velocity
player_health = 100
inventory = []
# Main game loop control
running = True
clock = pygame.time.Clock()
# Call show_intro() and get the button_assigned_functions list
button_assignments, button_assigned_functions = show_intro()
# Initialize player jumping state
player_is_jumping = False
# Create a rect for the player sprite
player_rect = player_sprite.rect
# In the main game loop
while running:
# ...
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
# Process KEYDOWN events individually
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE and not player_is_jumping:
# Start jumping
player_is_jumping = True
player_vert_vel = -player_jump_vel
if event.key == ord('v'): # Pressed V
try:
button_assigned_functions[0](player_sprite.rect) # Pass player_sprite.rect
except Exception as e:
print(f"Error calling tool function 1: {e}")
elif event.key == ord('b'): # Pressed B
try:
button_assigned_functions[1](player_sprite.rect) # Pass player_sprite.rect
except Exception as e:
print(f"Error calling tool function 2: {e}")
elif event.key == ord('n'): # Pressed N
try:
button_assigned_functions[2](player_sprite.rect) # Pass player_sprite.rect
except Exception as e:
print(f"Error calling tool function 3: {e}")
# 2. Update game state
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT]:
player_sprite.rect.x -= player_speed
if keys[pygame.K_RIGHT]:
player_sprite.rect.x += player_speed
if keys[pygame.K_UP]:
player_sprite.rect.y -= player_speed
if keys[pygame.K_DOWN]:
player_sprite.rect.y += player_speed
# Update player's vertical velocity and position if jumping
if player_is_jumping:
player_vert_vel += GRAVITY
player_sprite.rect.y += player_vert_vel
# Check if the player has landed on floor or stairs
if is_on_floor_or_stairs(player_sprite.rect):
player_is_jumping = False
player_vert_vel = 0
else:
# Apply gravity only if not on floor or stairs
if not is_on_floor_or_stairs(player_sprite.rect):
player_vert_vel += GRAVITY
player_sprite.rect.y += player_vert_vel
# Reset vertical velocity if on floor or stairs
if is_on_floor_or_stairs(player_sprite.rect):
player_vert_vel = 0
# Prevent the player from moving off screen
player_sprite.rect.clamp_ip(screen.get_rect())
# 3. Draw everything
screen.blit(background, (0, 0))
draw_floor()
draw_doors()
tools.draw(screen)
enemies.draw(screen)
screen.blit(player_sprite.image, player_sprite.rect) # Draw player
# Check if the player is invisible
if invisible:
# Get the updated player position
player_x, player_y = player_sprite.rect.topleft
# Draw the invisibility cloak image over the player
screen.blit(invisibility_cloak_image, (player_x, player_y))
# After drawing everything, update/flip the display
pygame.display.flip()
# 4. Cap the frame rate
clock.tick(60)
if __name__ == "__main__":
main() now code to beat the level the player has to reach enter either door, to enter door 1 player just has to reach it because its open but for door 2 its locked so player needs to have the key. the doors take them to level 2].
|
704d859f381abbf48b5e1e580b8c0308
|
{
"intermediate": 0.2879960834980011,
"beginner": 0.45061373710632324,
"expert": 0.26139017939567566
}
|
44,439
|
import pygame
import random
import math
# Initialize pygame and create a screen object
pygame.init()
screen = pygame.display.set_mode((1000, 800))
# Define colors
BLACK = (0, 0, 0)
RED = (255, 0, 0)
YELLOW = (255, 255, 0)
BLUE = (0, 0, 255)
# Define grid size
GRID_WIDTH = 21
GRID_HEIGHT = 17
# Initialize the invisible variable
invisible = False
# Define initial floor position
FLOOR_START_ROW = GRID_HEIGHT - 2
FLOOR_END_ROW = GRID_HEIGHT - 1
pygame.display.set_caption('100% no luck')
# Load the images for the background, the player, and the boss
# Ensure that these images are present in your project directory
try:
background = pygame.image.load('level_1_background.jpeg')
player_image = pygame.image.load('player1_back.png')
invisibility_cloak_image = pygame.image.load('invisibility_cloak.png')
grappling_hook_image = pygame.image.load('grappling_hook.png')
katana_image = pygame.image.load('katana.png')
freezing_ray_image = pygame.image.load('freezing_ray.png')
speed_pill_image = pygame.image.load('speed_pill.jpeg')
bouncy_shoes_image = pygame.image.load('bouncy_shoes.png')
key_image = pygame.image.load('key.png')
tsunami_maker_image = pygame.image.load('tsunami_maker.png')
laser_beam_image = pygame.image.load('laser_beam.png')
go_kart_image = pygame.image.load('go_kart.jpeg')
revival_kit_image = pygame.image.load('revival_kit.jpeg')
except pygame.error as e:
print("Cannot load images:", e)
raise SystemExit
# Define the colors for the text
WHITE = (255, 255, 255)
# Define the font for the text
font = pygame.font.SysFont('Arial', 32)
# Define the text for the intro and the tools
intro_text = "Welcome to 100% no luck, a game where you have to use smart logic and some luck to beat the dungeon. You will spawn with 3 tools out of a possible 15 tools randomized. Each tool has a different effect and can help you or hinder you depending on the situation. You have to think carefully about how to use your tools and when to use them. The dungeon has many obstacles and enemies that you have to overcome. The goal is to reach the end of the dungeon and defeat the boss. Good luck!"
tools_text = ["Invisibility cloak: Makes you invisible for 10 seconds. Useful for sneaking past enemies or traps.",
"Grappling hook: Allows you to swing across gaps or pull objects towards you.",
"Katana: A sharp sword that can cut through anything. Useful for fighting enemies or breaking barriers.",
"Freeze ray: A device that can freeze anything in its path. Useful for stopping enemies or creating platforms.",
"Bouncy shoes: Shoes that make you jump higher and farther. Useful for reaching high places or avoiding obstacles.",
"Key: A key that can unlock any door or chest. Useful for accessing hidden areas or treasures.",
"Go kart: A vehicle that can move fast and run over anything. Useful for escaping enemies or crossing large distances.",
"Tsunami maker: A device that can create a huge wave of water. Useful for washing away enemies or filling gaps.",
"Laser beam: A device that can shoot a powerful laser. Useful for destroying enemies or barriers.",
"Speed pill: A pill that can make you move faster for 10 seconds. Useful for dodging enemies or traps.",
"Revival kit: A kit that can revive you once if you die. Useful for surviving fatal situations."]
def show_intro():
intro_text = "Welcome to 100% no luck, a game where you have to use smart logic and some luck to beat the dungeon. You will spawn with 3 tools out of a possible 15 tools randomized. Each tool has a different effect and can help you or hinder you depending on the situation. You have to think carefully about how to use your tools and when to use them. The dungeon has many obstacles and enemies that you have to overcome. The goal is to reach the end of the dungeon and defeat the boss. Good luck!"
# Wrap the intro text
intro_lines = []
max_width = 950 # Adjust as needed
words = intro_text.split()
current_line = words[0]
for word in words[1:]:
if font.size(current_line + ' ' + word)[0] < max_width:
current_line += ' ' + word
else:
intro_lines.append(current_line)
current_line = word
intro_lines.append(current_line)
current_line = 0
intro_complete = False
start_time = pygame.time.get_ticks()
while not intro_complete:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
screen.fill((0, 0, 0))
intro_surface = font.render(intro_lines[current_line], True, WHITE)
intro_rect = intro_surface.get_rect(center=(screen.get_width() // 2, screen.get_height() // 2))
screen.blit(intro_surface, intro_rect)
if pygame.time.get_ticks() - start_time > 2980:
current_line += 1
start_time = pygame.time.get_ticks()
if current_line == len(intro_lines):
intro_complete = True
pygame.display.flip()
pygame.time.Clock().tick(60)
screen.fill((0, 0, 0))
pygame.display.flip()
tools_title_surface = font.render("Selected Tools:", True, WHITE)
tools_title_rect = tools_title_surface.get_rect(center=(screen.get_width() // 2, 100))
screen.blit(tools_title_surface, tools_title_rect)
pygame.display.flip()
pygame.time.delay(1000)
available_buttons = ['v', 'b', 'n', 'x', 'y', 'z'] # Add more buttons if needed
selected_tools = random.sample(tools_text, 3)
# Assign buttons to the selected tools
button_assignments = available_buttons[:3] # Take the first three buttons
button_assigned_functions = [tool_functions[tools_text.index(tool)] for tool in selected_tools]
# Wrap the tool descriptions and display them with their assigned buttons
wrapped_tools = []
for i, tool_desc in enumerate(selected_tools):
tool_lines = []
current_line = f"{button_assignments[i]}: {tool_desc.split()[0]}"
for word in tool_desc.split()[1:]:
if font.size(current_line + ' ' + word)[0] < max_width:
current_line += ' ' + word
else:
tool_lines.append(current_line)
current_line = word
tool_lines.append(current_line)
wrapped_tools.append(tool_lines)
selected_tools_surface = [font.render(line, True, WHITE) for tool_lines in wrapped_tools for line in tool_lines]
for i, tool_surface in enumerate(selected_tools_surface):
tool_rect = tool_surface.get_rect(center=(screen.get_width() // 2, 200 + i * 50))
screen.blit(tool_surface, tool_rect)
pygame.display.flip()
start_time = pygame.time.get_ticks()
while pygame.time.get_ticks() - start_time < 2000:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
screen.fill((0, 0, 0))
pygame.display.flip()
return button_assignments, button_assigned_functions
# Define the logic for each tool as a function
def invisibility_cloak(player_rect):
# Set a global variable to indicate that the player is invisible
global invisible
invisible = True
# Set a timer to make the player visible again after 10 seconds
pygame.time.set_timer(pygame.USEREVENT, 10000)
# Create a Rect for the invisibility cloak sprite
cloak_rect = player_rect.copy()
cloak_rect.inflate_ip(50, 50)
# Load the invisibility cloak image
try:
cloak_surf = pygame.image.load('invisibility_cloak.png')
except pygame.error as e:
print(f"Cannot load invisibility cloak image: {e}")
return
while invisible:
# Draw the invisibility cloak sprite over the player
screen.blit(cloak_surf, cloak_rect)
# Update the cloak position based on the player's position
cloak_rect.center = player_rect.center
# Check for events
for event in pygame.event.get():
if event.type == pygame.USEREVENT:
# Stop the invisibility cloak effect
invisible = False
# Update the display
pygame.display.flip()
# Limit the frame rate
pygame.time.Clock().tick(60)
# Reset the invisible state
invisible = False
def grappling_hook(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the distance and the angle between the mouse and the player
distance = ((mouse_x - player_x) ** 2 + (mouse_y - player_y) ** 2) ** 0.5
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, BLACK, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the mouse is over a gap or an object
if mouse_x > 600 and mouse_x < 700 and mouse_y > 300 and mouse_y < 400:
# If the mouse is over a gap, move the player towards the mouse
player_rect.centerx += math.cos(angle) * 10
player_rect.centery += math.sin(angle) * 10
elif mouse_x > 700 and mouse_x < 800 and mouse_y > 200 and mouse_y < 300:
# If the mouse is over an object, move the object towards the player
object_rect.centerx -= math.cos(angle) * 10
object_rect.centery -= math.sin(angle) * 10
def katana(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Randomly choose between the two attacks
attack_type = random.randint(1, 2)
# Load the katana image
try:
katana_surf = pygame.image.load('katana.png')
except pygame.error as e:
print(f"Cannot load katana image: {e}")
return
# Create a temporary sprite for the katana
katana_sprite = pygame.sprite.Sprite()
katana_sprite.image = katana_surf
katana_sprite.rect = katana_sprite.image.get_rect()
katana_sprite.rect.center = player_rect.center
if attack_type == 1:
# Attack 1: Player moves/slashes in a random direction
angle = random.uniform(0, 2 * math.pi) # Random angle
slash_distance = 198 # Distance to move/slash
new_x = player_x + math.cos(angle) * slash_distance
new_y = player_y + math.sin(angle) * slash_distance
player_rect.center = (new_x, new_y)
# Draw the katana image on the player
katana_sprite.rect.center = player_rect.center
screen.blit(katana_sprite.image, katana_sprite.rect)
else:
# Attack 2: Throw the katana towards the mouse position
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
katana_sprite.image = pygame.transform.rotate(katana_sprite.image, math.degrees(angle))
katana_sprite.rect = katana_sprite.image.get_rect()
katana_sprite.rect.center = (player_x, player_y)
screen.blit(katana_sprite.image, katana_sprite.rect)
# Move the katana towards the mouse position
dx = mouse_x - player_x
dy = mouse_y - player_y
distance = (dx ** 2 + dy ** 2) ** 0.5
katana_speed = 10
katana_sprite.rect.x += dx / distance * katana_speed
katana_sprite.rect.y += dy / distance * katana_speed
# Check if the katana has reached the mouse position
if katana_sprite.rect.collidepoint(mouse_x, mouse_y):
# Reset the katana position
katana_sprite.rect.center = player_rect.center
def bouncy_shoes(player_rect):
# Set a global variable to indicate that the player has bouncy shoes
global bouncy, player_jump_vel
bouncy = True
# Increase the player's jump velocity
player_jump_vel = 20
def key(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the distance between the mouse and the player
distance = ((mouse_x - player_x) ** 2 + (mouse_y - player_y) ** 2) ** 0.5
# Check if the mouse is over a door or a chest
if pygame.sprite.spritecollideany(mouse, doors) or pygame.sprite.spritecollideany(mouse, chests):
# If the mouse is over a door or a chest, unlock it and open it
pygame.sprite.spritecollide(mouse, doors, True)
pygame.sprite.spritecollide(mouse, chests, True)
# If the chest contains a tool, add it to the player's inventory
if chest.tool:
inventory.append(chest.tool)
def go_kart(player_rect):
# Set a global variable to indicate that the player is in a go kart
global go_kart
go_kart = True
# Increase the player's speed and size
player_speed = 15
player_rect.inflate_ip(50, 50)
# Load the image for the go kart
go_kart_image = pygame.image.load('go_kart.jpeg')
# Draw the go kart over the player
screen.blit(go_kart_image, player_rect)
# Check if the player collides with an enemy or a barrier
collided_enemies = pygame.sprite.spritecollide(player_sprite, enemies, True)
collided_barriers = pygame.sprite.spritecollide(player_sprite, barriers, True)
def freeze_ray(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the angle between the mouse and the player
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Create a line surface from the player to the mouse
line_length = math.hypot(mouse_x - player_x, mouse_y - player_y)
line = pygame.Surface((line_length, 5), pygame.SRCALPHA)
line.fill(BLUE)
line_rect = line.get_rect()
line_rect.center = player_rect.center
# Rotate the line surface
rotated_line = pygame.transform.rotate(line, math.degrees(angle))
# Draw the rotated line on the screen
screen.blit(rotated_line, (player_x, player_y))
# Create a temporary sprite for the line
line_sprite = pygame.sprite.Sprite()
line_sprite.image = rotated_line
line_sprite.rect = rotated_line.get_rect(center=line_rect.center)
# Check if the line intersects with an enemy or a platform
enemies_hit = pygame.sprite.spritecollide(line_sprite, enemies, False)
platforms_hit = pygame.sprite.spritecollide(line_sprite, platforms, False)
# Freeze the enemies and platforms that were hit
for enemy in enemies_hit:
freeze(enemy)
for platform in platforms_hit:
freeze(platform)
def freeze(sprite):
# Change the sprite's image to a frozen version
sprite.image = pygame.image.load(sprite.name + '_frozen.png')
# Set the sprite's frozen attribute to True
sprite.frozen = True
def tsunami_maker(player_rect):
global tsunami
tsunami = True
wave_surf = pygame.image.load('tsunami_maker.png')
# Resize the wave_surf to make it taller
wave_surf = pygame.transform.scale(wave_surf, (wave_surf.get_width(), wave_surf.get_height() * 3))
wave_sprite = pygame.sprite.Sprite()
wave_sprite.image = wave_surf
wave_sprite.rect = wave_sprite.image.get_rect()
wave_sprite.rect.bottomleft = (0, screen.get_height())
wave_speed = 10
while tsunami:
screen.blit(wave_sprite.image, wave_sprite.rect)
wave_sprite.rect.x += wave_speed
if wave_sprite.rect.right >= screen.get_width():
tsunami = False
pygame.display.flip()
def laser_beam(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the angle between the mouse and the player
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, YELLOW, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the line intersects with an enemy or a barrier
if pygame.sprite.spritecollideany(line, enemies) or pygame.sprite.spritecollideany(line, barriers):
# If the line intersects with an enemy or a barrier, destroy it
pygame.sprite.spritecollide(line, enemies, True)
pygame.sprite.spritecollide(line, barriers, True)
def speed_pill(player_rect):
# Set a global variable to indicate that the player has used the speed pill
global speed
speed = True
# Set a timer to make the player normal again after 10 seconds
pygame.time.set_timer(pygame.USEREVENT + 1, 10000)
# Increase the player's speed
player_speed = 10
def revival_kit(player_rect):
# Set a global variable to indicate that the player has a revival kit
global revival
revival = True
global player_health
# Check if the player's health is zero
if player_health == 0:
# If the player's health is zero, revive the player
player_health = 100
# Set the revival variable to False
revival = False
tool_functions = [invisibility_cloak, grappling_hook, katana, freeze_ray, bouncy_shoes, key,
go_kart, tsunami_maker, laser_beam, speed_pill, revival_kit]
def is_on_floor_or_stairs(player_rect):
"""
Check if the player is standing on a floor or stairs cell.
Returns True if standing on floor or stairs, False otherwise.
"""
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Check if the player is on the initial floor rows
if FLOOR_START_ROW <= player_rect.bottom // cell_height <= FLOOR_END_ROW:
for x in range(player_rect.left // cell_width, (player_rect.right + cell_width - 1) // cell_width):
if 0 <= x < GRID_WIDTH:
return True
return False
def draw_doors():
# Define the door's color
DOOR_COLOR = (139, 69, 19) # Saddle brown color
# Calculate the cell size based on the screen dimensions
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Draw door 1
door1_start_row = GRID_HEIGHT - 10
door1_end_row = GRID_HEIGHT - 13
door1_start_col = 10
door1_end_col = 11
for row in range(door1_start_row, door1_end_row - 1, -1):
for col in range(door1_start_col, door1_end_col + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, DOOR_COLOR, rect)
# Draw door 2
door2_start_row = GRID_HEIGHT - 3
door2_end_row = GRID_HEIGHT - 4
door2_start_col = 16
door2_end_col = 17
for row in range(door2_start_row, door2_end_row - 1, -1):
for col in range(door2_start_col, door2_end_col + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, DOOR_COLOR, rect)
def draw_floor():
# Define the floor's color
FLOOR_COLOR = (128, 64, 0) # Brown color
STAIRS_COLOR = (128, 128, 128) # Gray color
# Calculate the cell size based on the screen dimensions
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Draw the floor cells
for col in range(GRID_WIDTH):
for row in range(FLOOR_START_ROW, FLOOR_END_ROW + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, FLOOR_COLOR, rect)
enemies = pygame.sprite.Group()
barriers = pygame.sprite.Group()
platforms = pygame.sprite.Group()
doors = pygame.sprite.Group()
chests = pygame.sprite.Group()
gaps = pygame.sprite.Group()
tools = pygame.sprite.Group()
# Create some sprites and groups for the player
player_sprite = pygame.sprite.Sprite()
player_sprite.image = player_image
player_sprite.rect = player_sprite.image.get_rect()
player_sprite.rect.center = (100, 300)
# Create sprite groups
enemies = pygame.sprite.Group()
tools = pygame.sprite.Group() # Assuming tools are also Sprites
# Gravity constant
GRAVITY = 0.5
# Player properties
player_x = 100
player_y = 300
player_speed = 5
player_jump_vel = 10
player_vert_vel = 0 # Initial vertical velocity
player_health = 100
inventory = []
# Main game loop control
running = True
clock = pygame.time.Clock()
# Call show_intro() and get the button_assigned_functions list
button_assignments, button_assigned_functions = show_intro()
# Initialize player jumping state
player_is_jumping = False
# Create a rect for the player sprite
player_rect = player_sprite.rect
# In the main game loop
while running:
# ...
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
# Process KEYDOWN events individually
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE and not player_is_jumping:
# Start jumping
player_is_jumping = True
player_vert_vel = -player_jump_vel
if event.key == ord('v'): # Pressed V
try:
button_assigned_functions[0](player_sprite.rect) # Pass player_sprite.rect
except Exception as e:
print(f"Error calling tool function 1: {e}")
elif event.key == ord('b'): # Pressed B
try:
button_assigned_functions[1](player_sprite.rect) # Pass player_sprite.rect
except Exception as e:
print(f"Error calling tool function 2: {e}")
elif event.key == ord('n'): # Pressed N
try:
button_assigned_functions[2](player_sprite.rect) # Pass player_sprite.rect
except Exception as e:
print(f"Error calling tool function 3: {e}")
# 2. Update game state
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT]:
player_sprite.rect.x -= player_speed
if keys[pygame.K_RIGHT]:
player_sprite.rect.x += player_speed
if keys[pygame.K_UP]:
player_sprite.rect.y -= player_speed
if keys[pygame.K_DOWN]:
player_sprite.rect.y += player_speed
# Update player's vertical velocity and position if jumping
if player_is_jumping:
player_vert_vel += GRAVITY
player_sprite.rect.y += player_vert_vel
# Check if the player has landed on floor or stairs
if is_on_floor_or_stairs(player_sprite.rect):
player_is_jumping = False
player_vert_vel = 0
else:
# Apply gravity only if not on floor or stairs
if not is_on_floor_or_stairs(player_sprite.rect):
player_vert_vel += GRAVITY
player_sprite.rect.y += player_vert_vel
# Reset vertical velocity if on floor or stairs
if is_on_floor_or_stairs(player_sprite.rect):
player_vert_vel = 0
# Prevent the player from moving off screen
player_sprite.rect.clamp_ip(screen.get_rect())
# 3. Draw everything
screen.blit(background, (0, 0))
draw_floor()
draw_doors()
tools.draw(screen)
enemies.draw(screen)
screen.blit(player_sprite.image, player_sprite.rect) # Draw player
# Check if the player is invisible
if invisible:
# Get the updated player position
player_x, player_y = player_sprite.rect.topleft
# Draw the invisibility cloak image over the player
screen.blit(invisibility_cloak_image, (player_x, player_y))
# After drawing everything, update/flip the display
pygame.display.flip()
# 4. Cap the frame rate
clock.tick(60)
if __name__ == "__main__":
main() now code to beat the level the player has to reach enter either door, to enter door 1 player just has to reach it because its open but for door 2 its locked so player needs to have the key. this sends the player to level 2.
|
6d429577dc28f26aab4ea779cfc1715b
|
{
"intermediate": 0.2879960834980011,
"beginner": 0.45061373710632324,
"expert": 0.26139017939567566
}
|
44,440
|
import pygame
import random
import math
# Initialize pygame and create a screen object
pygame.init()
screen = pygame.display.set_mode((1000, 800))
# Define colors
BLACK = (0, 0, 0)
RED = (255, 0, 0)
YELLOW = (255, 255, 0)
BLUE = (0, 0, 255)
# Define grid size
GRID_WIDTH = 21
GRID_HEIGHT = 17
# Initialize the invisible variable
invisible = False
# Define initial floor position
FLOOR_START_ROW = GRID_HEIGHT - 2
FLOOR_END_ROW = GRID_HEIGHT - 1
pygame.display.set_caption(‘100% no luck’)
# Load the images for the background, the player, and the boss
# Ensure that these images are present in your project directory
try:
background = pygame.image.load(‘level_1_background.jpeg’)
player_image = pygame.image.load(‘player1_back.png’)
invisibility_cloak_image = pygame.image.load(‘invisibility_cloak.png’)
grappling_hook_image = pygame.image.load(‘grappling_hook.png’)
katana_image = pygame.image.load(‘katana.png’)
freezing_ray_image = pygame.image.load(‘freezing_ray.png’)
speed_pill_image = pygame.image.load(‘speed_pill.jpeg’)
bouncy_shoes_image = pygame.image.load(‘bouncy_shoes.png’)
key_image = pygame.image.load(‘key.png’)
tsunami_maker_image = pygame.image.load(‘tsunami_maker.png’)
laser_beam_image = pygame.image.load(‘laser_beam.png’)
go_kart_image = pygame.image.load(‘go_kart.jpeg’)
revival_kit_image = pygame.image.load(‘revival_kit.jpeg’)
except pygame.error as e:
print(“Cannot load images:”, e)
raise SystemExit
# Define the colors for the text
WHITE = (255, 255, 255)
# Define the font for the text
font = pygame.font.SysFont(‘Arial’, 32)
# Define the text for the intro and the tools
intro_text = “Welcome to 100% no luck, a game where you have to use smart logic and some luck to beat the dungeon. You will spawn with 3 tools out of a possible 15 tools randomized. Each tool has a different effect and can help you or hinder you depending on the situation. You have to think carefully about how to use your tools and when to use them. The dungeon has many obstacles and enemies that you have to overcome. The goal is to reach the end of the dungeon and defeat the boss. Good luck!”
tools_text = [“Invisibility cloak: Makes you invisible for 10 seconds. Useful for sneaking past enemies or traps.”,
“Grappling hook: Allows you to swing across gaps or pull objects towards you.”,
“Katana: A sharp sword that can cut through anything. Useful for fighting enemies or breaking barriers.”,
“Freeze ray: A device that can freeze anything in its path. Useful for stopping enemies or creating platforms.”,
“Bouncy shoes: Shoes that make you jump higher and farther. Useful for reaching high places or avoiding obstacles.”,
“Key: A key that can unlock any door or chest. Useful for accessing hidden areas or treasures.”,
“Go kart: A vehicle that can move fast and run over anything. Useful for escaping enemies or crossing large distances.”,
“Tsunami maker: A device that can create a huge wave of water. Useful for washing away enemies or filling gaps.”,
“Laser beam: A device that can shoot a powerful laser. Useful for destroying enemies or barriers.”,
“Speed pill: A pill that can make you move faster for 10 seconds. Useful for dodging enemies or traps.”,
“Revival kit: A kit that can revive you once if you die. Useful for surviving fatal situations.”]
def show_intro():
intro_text = “Welcome to 100% no luck, a game where you have to use smart logic and some luck to beat the dungeon. You will spawn with 3 tools out of a possible 15 tools randomized. Each tool has a different effect and can help you or hinder you depending on the situation. You have to think carefully about how to use your tools and when to use them. The dungeon has many obstacles and enemies that you have to overcome. The goal is to reach the end of the dungeon and defeat the boss. Good luck!”
# Wrap the intro text
intro_lines = []
max_width = 950 # Adjust as needed
words = intro_text.split()
current_line = words[0]
for word in words[1:]:
if font.size(current_line + ’ ’ + word)[0] < max_width:
current_line += ’ ’ + word
else:
intro_lines.append(current_line)
current_line = word
intro_lines.append(current_line)
current_line = 0
intro_complete = False
start_time = pygame.time.get_ticks()
while not intro_complete:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
screen.fill((0, 0, 0))
intro_surface = font.render(intro_lines[current_line], True, WHITE)
intro_rect = intro_surface.get_rect(center=(screen.get_width() // 2, screen.get_height() // 2))
screen.blit(intro_surface, intro_rect)
if pygame.time.get_ticks() - start_time > 2980:
current_line += 1
start_time = pygame.time.get_ticks()
if current_line == len(intro_lines):
intro_complete = True
pygame.display.flip()
pygame.time.Clock().tick(60)
screen.fill((0, 0, 0))
pygame.display.flip()
tools_title_surface = font.render(“Selected Tools:”, True, WHITE)
tools_title_rect = tools_title_surface.get_rect(center=(screen.get_width() // 2, 100))
screen.blit(tools_title_surface, tools_title_rect)
pygame.display.flip()
pygame.time.delay(1000)
available_buttons = [‘v’, ‘b’, ‘n’, ‘x’, ‘y’, ‘z’] # Add more buttons if needed
selected_tools = random.sample(tools_text, 3)
# Assign buttons to the selected tools
button_assignments = available_buttons[:3] # Take the first three buttons
button_assigned_functions = [tool_functions[tools_text.index(tool)] for tool in selected_tools]
# Wrap the tool descriptions and display them with their assigned buttons
wrapped_tools = []
for i, tool_desc in enumerate(selected_tools):
tool_lines = []
current_line = f"{button_assignments[i]}: {tool_desc.split()[0]}“
for word in tool_desc.split()[1:]:
if font.size(current_line + ’ ’ + word)[0] < max_width:
current_line += ’ ’ + word
else:
tool_lines.append(current_line)
current_line = word
tool_lines.append(current_line)
wrapped_tools.append(tool_lines)
selected_tools_surface = [font.render(line, True, WHITE) for tool_lines in wrapped_tools for line in tool_lines]
for i, tool_surface in enumerate(selected_tools_surface):
tool_rect = tool_surface.get_rect(center=(screen.get_width() // 2, 200 + i * 50))
screen.blit(tool_surface, tool_rect)
pygame.display.flip()
start_time = pygame.time.get_ticks()
while pygame.time.get_ticks() - start_time < 2000:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
screen.fill((0, 0, 0))
pygame.display.flip()
return button_assignments, button_assigned_functions
# Define the logic for each tool as a function
def invisibility_cloak(player_rect):
# Set a global variable to indicate that the player is invisible
global invisible
invisible = True
# Set a timer to make the player visible again after 10 seconds
pygame.time.set_timer(pygame.USEREVENT, 10000)
# Create a Rect for the invisibility cloak sprite
cloak_rect = player_rect.copy()
cloak_rect.inflate_ip(50, 50)
# Load the invisibility cloak image
try:
cloak_surf = pygame.image.load(‘invisibility_cloak.png’)
except pygame.error as e:
print(f"Cannot load invisibility cloak image: {e}”)
return
while invisible:
# Draw the invisibility cloak sprite over the player
screen.blit(cloak_surf, cloak_rect)
# Update the cloak position based on the player’s position
cloak_rect.center = player_rect.center
# Check for events
for event in pygame.event.get():
if event.type == pygame.USEREVENT:
# Stop the invisibility cloak effect
invisible = False
# Update the display
pygame.display.flip()
# Limit the frame rate
pygame.time.Clock().tick(60)
# Reset the invisible state
invisible = False
def grappling_hook(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the distance and the angle between the mouse and the player
distance = ((mouse_x - player_x) ** 2 + (mouse_y - player_y) ** 2) ** 0.5
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, BLACK, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the mouse is over a gap or an object
if mouse_x > 600 and mouse_x < 700 and mouse_y > 300 and mouse_y < 400:
# If the mouse is over a gap, move the player towards the mouse
player_rect.centerx += math.cos(angle) * 10
player_rect.centery += math.sin(angle) * 10
elif mouse_x > 700 and mouse_x < 800 and mouse_y > 200 and mouse_y < 300:
# If the mouse is over an object, move the object towards the player
object_rect.centerx -= math.cos(angle) * 10
object_rect.centery -= math.sin(angle) * 10
def katana(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Randomly choose between the two attacks
attack_type = random.randint(1, 2)
# Load the katana image
try:
katana_surf = pygame.image.load(‘katana.png’)
except pygame.error as e:
print(f"Cannot load katana image: {e}“)
return
# Create a temporary sprite for the katana
katana_sprite = pygame.sprite.Sprite()
katana_sprite.image = katana_surf
katana_sprite.rect = katana_sprite.image.get_rect()
katana_sprite.rect.center = player_rect.center
if attack_type == 1:
# Attack 1: Player moves/slashes in a random direction
angle = random.uniform(0, 2 * math.pi) # Random angle
slash_distance = 198 # Distance to move/slash
new_x = player_x + math.cos(angle) * slash_distance
new_y = player_y + math.sin(angle) * slash_distance
player_rect.center = (new_x, new_y)
# Draw the katana image on the player
katana_sprite.rect.center = player_rect.center
screen.blit(katana_sprite.image, katana_sprite.rect)
else:
# Attack 2: Throw the katana towards the mouse position
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
katana_sprite.image = pygame.transform.rotate(katana_sprite.image, math.degrees(angle))
katana_sprite.rect = katana_sprite.image.get_rect()
katana_sprite.rect.center = (player_x, player_y)
screen.blit(katana_sprite.image, katana_sprite.rect)
# Move the katana towards the mouse position
dx = mouse_x - player_x
dy = mouse_y - player_y
distance = (dx ** 2 + dy ** 2) ** 0.5
katana_speed = 10
katana_sprite.rect.x += dx / distance * katana_speed
katana_sprite.rect.y += dy / distance * katana_speed
# Check if the katana has reached the mouse position
if katana_sprite.rect.collidepoint(mouse_x, mouse_y):
# Reset the katana position
katana_sprite.rect.center = player_rect.center
def bouncy_shoes(player_rect):
# Set a global variable to indicate that the player has bouncy shoes
global bouncy, player_jump_vel
bouncy = True
# Increase the player’s jump velocity
player_jump_vel = 20
def key(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the distance between the mouse and the player
distance = ((mouse_x - player_x) ** 2 + (mouse_y - player_y) ** 2) ** 0.5
# Check if the mouse is over a door or a chest
if pygame.sprite.spritecollideany(mouse, doors) or pygame.sprite.spritecollideany(mouse, chests):
# If the mouse is over a door or a chest, unlock it and open it
pygame.sprite.spritecollide(mouse, doors, True)
pygame.sprite.spritecollide(mouse, chests, True)
# If the chest contains a tool, add it to the player’s inventory
if chest.tool:
inventory.append(chest.tool)
def go_kart(player_rect):
# Set a global variable to indicate that the player is in a go kart
global go_kart
go_kart = True
# Increase the player’s speed and size
player_speed = 15
player_rect.inflate_ip(50, 50)
# Load the image for the go kart
go_kart_image = pygame.image.load(‘go_kart.jpeg’)
# Draw the go kart over the player
screen.blit(go_kart_image, player_rect)
# Check if the player collides with an enemy or a barrier
collided_enemies = pygame.sprite.spritecollide(player_sprite, enemies, True)
collided_barriers = pygame.sprite.spritecollide(player_sprite, barriers, True)
def freeze_ray(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the angle between the mouse and the player
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Create a line surface from the player to the mouse
line_length = math.hypot(mouse_x - player_x, mouse_y - player_y)
line = pygame.Surface((line_length, 5), pygame.SRCALPHA)
line.fill(BLUE)
line_rect = line.get_rect()
line_rect.center = player_rect.center
# Rotate the line surface
rotated_line = pygame.transform.rotate(line, math.degrees(angle))
# Draw the rotated line on the screen
screen.blit(rotated_line, (player_x, player_y))
# Create a temporary sprite for the line
line_sprite = pygame.sprite.Sprite()
line_sprite.image = rotated_line
line_sprite.rect = rotated_line.get_rect(center=line_rect.center)
# Check if the line intersects with an enemy or a platform
enemies_hit = pygame.sprite.spritecollide(line_sprite, enemies, False)
platforms_hit = pygame.sprite.spritecollide(line_sprite, platforms, False)
# Freeze the enemies and platforms that were hit
for enemy in enemies_hit:
freeze(enemy)
for platform in platforms_hit:
freeze(platform)
def freeze(sprite):
# Change the sprite’s image to a frozen version
sprite.image = pygame.image.load(sprite.name + ‘_frozen.png’)
# Set the sprite’s frozen attribute to True
sprite.frozen = True
def tsunami_maker(player_rect):
global tsunami
tsunami = True
wave_surf = pygame.image.load(‘tsunami_maker.png’)
# Resize the wave_surf to make it taller
wave_surf = pygame.transform.scale(wave_surf, (wave_surf.get_width(), wave_surf.get_height() * 3))
wave_sprite = pygame.sprite.Sprite()
wave_sprite.image = wave_surf
wave_sprite.rect = wave_sprite.image.get_rect()
wave_sprite.rect.bottomleft = (0, screen.get_height())
wave_speed = 10
while tsunami:
screen.blit(wave_sprite.image, wave_sprite.rect)
wave_sprite.rect.x += wave_speed
if wave_sprite.rect.right >= screen.get_width():
tsunami = False
pygame.display.flip()
def laser_beam(player_rect):
# Get the mouse position and the player position
mouse_x, mouse_y = pygame.mouse.get_pos()
player_x, player_y = player_rect.center
# Calculate the angle between the mouse and the player
angle = math.atan2(mouse_y - player_y, mouse_x - player_x)
# Draw a line from the player to the mouse
pygame.draw.line(screen, YELLOW, (player_x, player_y), (mouse_x, mouse_y), 5)
# Check if the line intersects with an enemy or a barrier
if pygame.sprite.spritecollideany(line, enemies) or pygame.sprite.spritecollideany(line, barriers):
# If the line intersects with an enemy or a barrier, destroy it
pygame.sprite.spritecollide(line, enemies, True)
pygame.sprite.spritecollide(line, barriers, True)
def speed_pill(player_rect):
# Set a global variable to indicate that the player has used the speed pill
global speed
speed = True
# Set a timer to make the player normal again after 10 seconds
pygame.time.set_timer(pygame.USEREVENT + 1, 10000)
# Increase the player’s speed
player_speed = 10
def revival_kit(player_rect):
# Set a global variable to indicate that the player has a revival kit
global revival
revival = True
global player_health
# Check if the player’s health is zero
if player_health == 0:
# If the player’s health is zero, revive the player
player_health = 100
# Set the revival variable to False
revival = False
tool_functions = [invisibility_cloak, grappling_hook, katana, freeze_ray, bouncy_shoes, key,
go_kart, tsunami_maker, laser_beam, speed_pill, revival_kit]
def is_on_floor_or_stairs(player_rect):
“””
Check if the player is standing on a floor or stairs cell.
Returns True if standing on floor or stairs, False otherwise.
“”“
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Check if the player is on the initial floor rows
if FLOOR_START_ROW <= player_rect.bottom // cell_height <= FLOOR_END_ROW:
for x in range(player_rect.left // cell_width, (player_rect.right + cell_width - 1) // cell_width):
if 0 <= x < GRID_WIDTH:
return True
return False
def draw_doors():
# Define the door’s color
DOOR_COLOR = (139, 69, 19) # Saddle brown color
# Calculate the cell size based on the screen dimensions
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Draw door 1
door1_start_row = GRID_HEIGHT - 10
door1_end_row = GRID_HEIGHT - 13
door1_start_col = 10
door1_end_col = 11
for row in range(door1_start_row, door1_end_row - 1, -1):
for col in range(door1_start_col, door1_end_col + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, DOOR_COLOR, rect)
# Draw door 2
door2_start_row = GRID_HEIGHT - 3
door2_end_row = GRID_HEIGHT - 4
door2_start_col = 16
door2_end_col = 17
for row in range(door2_start_row, door2_end_row - 1, -1):
for col in range(door2_start_col, door2_end_col + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, DOOR_COLOR, rect)
def draw_floor():
# Define the floor’s color
FLOOR_COLOR = (128, 64, 0) # Brown color
STAIRS_COLOR = (128, 128, 128) # Gray color
# Calculate the cell size based on the screen dimensions
cell_width = screen.get_width() // GRID_WIDTH
cell_height = screen.get_height() // GRID_HEIGHT
# Draw the floor cells
for col in range(GRID_WIDTH):
for row in range(FLOOR_START_ROW, FLOOR_END_ROW + 1):
rect = pygame.Rect(col * cell_width, row * cell_height, cell_width, cell_height)
pygame.draw.rect(screen, FLOOR_COLOR, rect)
enemies = pygame.sprite.Group()
barriers = pygame.sprite.Group()
platforms = pygame.sprite.Group()
doors = pygame.sprite.Group()
chests = pygame.sprite.Group()
gaps = pygame.sprite.Group()
tools = pygame.sprite.Group()
# Create some sprites and groups for the player
player_sprite = pygame.sprite.Sprite()
player_sprite.image = player_image
player_sprite.rect = player_sprite.image.get_rect()
player_sprite.rect.center = (100, 300)
# Create sprite groups
enemies = pygame.sprite.Group()
tools = pygame.sprite.Group() # Assuming tools are also Sprites
# Gravity constant
GRAVITY = 0.5
# Player properties
player_x = 100
player_y = 300
player_speed = 5
player_jump_vel = 10
player_vert_vel = 0 # Initial vertical velocity
player_health = 100
inventory = []
# Main game loop control
running = True
clock = pygame.time.Clock()
# Call show_intro() and get the button_assigned_functions list
button_assignments, button_assigned_functions = show_intro()
# Initialize player jumping state
player_is_jumping = False
# Create a rect for the player sprite
player_rect = player_sprite.rect
# In the main game loop
while running:
# …
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
# Process KEYDOWN events individually
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE and not player_is_jumping:
# Start jumping
player_is_jumping = True
player_vert_vel = -player_jump_vel
if event.key == ord(‘v’): # Pressed V
try:
button_assigned_functions0 # Pass player_sprite.rect
except Exception as e:
print(f"Error calling tool function 1: {e}”)
elif event.key == ord(‘b’): # Pressed B
try:
button_assigned_functions1 # Pass player_sprite.rect
except Exception as e:
print(f"Error calling tool function 2: {e}“)
elif event.key == ord(‘n’): # Pressed N
try:
button_assigned_functions2 # Pass player_sprite.rect
except Exception as e:
print(f"Error calling tool function 3: {e}”)
# 2. Update game state
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT]:
player_sprite.rect.x -= player_speed
if keys[pygame.K_RIGHT]:
player_sprite.rect.x += player_speed
if keys[pygame.K_UP]:
player_sprite.rect.y -= player_speed
if keys[pygame.K_DOWN]:
player_sprite.rect.y += player_speed
# Update player’s vertical velocity and position if jumping
if player_is_jumping:
player_vert_vel += GRAVITY
player_sprite.rect.y += player_vert_vel
# Check if the player has landed on floor or stairs
if is_on_floor_or_stairs(player_sprite.rect):
player_is_jumping = False
player_vert_vel = 0
else:
# Apply gravity only if not on floor or stairs
if not is_on_floor_or_stairs(player_sprite.rect):
player_vert_vel += GRAVITY
player_sprite.rect.y += player_vert_vel
# Reset vertical velocity if on floor or stairs
if is_on_floor_or_stairs(player_sprite.rect):
player_vert_vel = 0
# Prevent the player from moving off screen
player_sprite.rect.clamp_ip(screen.get_rect())
# 3. Draw everything
screen.blit(background, (0, 0))
draw_floor()
draw_doors()
tools.draw(screen)
enemies.draw(screen)
screen.blit(player_sprite.image, player_sprite.rect) # Draw player
# Check if the player is invisible
if invisible:
# Get the updated player position
player_x, player_y = player_sprite.rect.topleft
# Draw the invisibility cloak image over the player
screen.blit(invisibility_cloak_image, (player_x, player_y))
# After drawing everything, update/flip the display
pygame.display.flip()
# 4. Cap the frame rate
clock.tick(60)
if name == “main”:
main() now code to beat the level the player has to reach enter either door, to enter door 1 player just has to reach it because its open but for door 2 its locked so player needs to have the key. this activates you beat level 1 and sends the player to level 2. just send them there will make level 2 just now.
|
71df5321cf3955c0c7a2bdcca461c74a
|
{
"intermediate": 0.3274485170841217,
"beginner": 0.43859708309173584,
"expert": 0.23395441472530365
}
|
44,441
|
const updated = () => {
// whenever data changes and the component re-renders, this is called.
const lastElement = el.lastElementChild as HTMLDivElement
const BOX_SIZE = 257 * 2
if (!el || !lastElement) return
// console.log(this.$el.scrollHeight - this.$el.scrollTop, 'diff scroll')
if (el.scrollHeight - el.scrollTop < BOX_SIZE + lastElement.clientHeight) {
nextTick(() => this.scrollToEnd())
}
}
как переписать на vue 3
|
f6ccc22487976c910d966d298fc2b923
|
{
"intermediate": 0.44632869958877563,
"beginner": 0.39724642038345337,
"expert": 0.15642492473125458
}
|
44,442
|
how to make this css scrollable: <style> body {color: #778da9; background-color: #111111;} a { display:block; width:800px; position:fixed; left: 600px; margin: -170px; height: 30px; white-space: nowrap; font-size: 20px; font-family: Arial;} a:link {color: #778da9; font-size: 20px; font-family: Arial; text-decoration: none;} a:hover {color: #778da9; font-size: 20px; text-decoration: none;} a:visited {color: #778da9; font-size: 20px; text-decoration: none;} a:active {color: #778da9; font-size: 20px; text-decoration: none;} img {display: block; border-radius: 3%; width: 350px;}
</style>
|
78e38758c6b6f0b2e282698fc9948226
|
{
"intermediate": 0.3499107360839844,
"beginner": 0.3721078932285309,
"expert": 0.27798134088516235
}
|
44,443
|
Use the Glasgow Haskell Compiler ghc to implement all the functions specified in Main.hs and in the skeleton files referenced by Main.hs.
When a function requirement specifies a restriction on how that function should be implemented, your implementation must meet that restriction.
Main.hs
A skeleton file which contains specifications for the some of the functions you are required to write. For each function it contains a dummy implementation with a "TODO" error. It also contains QuickCheck tests for these functions as well as a main function which runs all of the tests for the entire project.
module Main (main) where
import TestUtils
import EvalIntExpr (testEvalIntExpr)
import EvalIdExpr (testEvalIdExpr)
import EvalMaybeExpr (testEvalMaybeExpr)
import PostfixExpr (testPostfixExpr)
import Test.QuickCheck
---------------------------- toSingletonLists ---------------------------
-- #1: 5-points
-- Use the map function to transform a list of elements e into
-- a list of singleton lists [e]. *Must use map*.
-- Hint: use map with a section.
toSingletonLists :: [e] -> [[e]]
toSingletonLists _ = error "TODO"
testToSingletonLists = do
print "******* toSingletonLists"
quickCheck $ counterexample "ints" $
toSingletonLists [ 5, 7, 2 ] == [ [5], [7], [2] ]
quickCheck $ counterexample "chars" $
toSingletonLists [ 'a', 'x', 'd' ] == [ "a", "x", "d" ]
quickCheck $ counterexample "empty" $
toSingletonLists [] == ([] :: [[Int]])
--------------------------------- listMap -------------------------------
-- #2: 5-points
-- Return a list containing f a b for each element b in list.
-- Hint: use the map function or a list comprehension
listMap :: (a -> b -> c) -> a -> [b] -> [c]
listMap _ _ _ = error "TODO"
testListMap = do
print "******* listMap"
quickCheck $ counterexample "add" $ listMap (+) 5 [1, 2, 3] == [6, 7, 8]
quickCheck $ counterexample "sub" $ listMap (-) 5 [1, 2, 3] == [4, 3, 2]
quickCheck $ counterexample "mul" $ listMap (*) 5 [1, 2, 3] == [5, 10, 15]
quickCheck $ counterexample "empty" $ listMap (-) 5 [] == []
---------------------------------- member -------------------------------
-- #3: 10-points
-- Use foldl to implement member e list which returns True iff
-- e is a member of list. *Must use foldl*, cannot use elem
-- Hint: define folding function using a lambda or local let/where definition;
-- also see definition of member in slides.
member :: Eq e => e -> [e] -> Bool
member _ _ = error "TODO"
testMember = do
print "******* member"
quickCheck $ counterexample "ints first" $ member 5 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints last" $ member 2 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints mid" $ member 7 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints fail" $ member 4 [ 5, 7, 2 ] == False
quickCheck $ counterexample "empty" $ member 4 [] == False
------------------------------- selectNApart ----------------------------
-- #4: 10-points
-- Given an Int n and a list of elements e, return a list
-- containing the elements of the list at index 0, n, 2n, 3n, 4n, ...
-- Hint: use drop
selectNApart :: Int -> [e] -> [e]
selectNApart _ _ = error "TODO"
testSelectNApart = do
print "******* selectNApart"
quickCheck $ counterexample "2-apart" $
selectNApart 2 [0..10] == [0, 2, 4, 6, 8, 10]
quickCheck $ counterexample "2-apart chars" $
selectNApart 2 ['a'..'z'] == "acegikmoqsuwy"
quickCheck $ counterexample "3-apart" $
selectNApart 3 [0..20] == [0, 3, 6, 9, 12, 15, 18]
quickCheck $ counterexample "5-apart" $
selectNApart 5 [0..21] == [0, 5, 10, 15, 20]
quickCheck $ counterexample "empty" $ selectNApart 5 ([]::[Int]) == []
------------------------ Functions in Separate Files --------------------
-- #5: 15-points
-- implement the specified function in EvalIntExpr.hs
-- #6: 15-points
-- implement the specified function in EvalIdExpr.hs
-- #7: 20-points
-- implement the specified function in EvalMaybeExpr.hs
-- #8: 20-points
-- implement the specified function in PostfixExpr.hs
--------------------------------- Tests ---------------------------------
-- Can mark test suites with following test statuses:
-- Only: run only these tests and other tests marked Only.
-- Run: run these tests when no tests are marked Only.
-- Skip: skip these tests.
allTests = [
(Skip testToSingletonLists),
(Skip testListMap),
(Skip testMember),
(Skip testSelectNApart),
(Skip testEvalIntExpr),
(Skip testEvalIdExpr),
(Skip testEvalMaybeExpr),
(Skip testPostfixExpr)
]
main = do
mapM_ id tests
where
only = onlyTests allTests
tests = if (length only > 0) then only else runTests allTests
EvalIntExpr.hs
This is a separate skeleton file for implementing a single function evalIntExpr.
module EvalIntExpr ( evalIntExpr, testEvalIntExpr, IntExpr(..) ) where
import Test.QuickCheck
-- an IntExpr is an expression-tree over integers
data IntExpr =
Leaf Int |
Add IntExpr IntExpr |
Sub IntExpr IntExpr |
Mul IntExpr IntExpr |
Uminus IntExpr
deriving (Eq, Show)
-- evalIntExpr returns the Int result of evaluating the IntExpr
-- expression-tree given by its argument.
evalIntExpr :: IntExpr -> Int
evalIntExpr _ = error "TODO"
testEvalIntExpr = do
print "******* test evalIntExpr"
quickCheck $ counterexample "Leaf" $ evalIntExpr (Leaf 42) == 42
quickCheck $ counterexample "Add" $
evalIntExpr (Add (Leaf 33) (Leaf 22)) == 55
quickCheck $ counterexample "Sub" $
evalIntExpr (Sub (Leaf 33) (Leaf 22)) == 11
quickCheck $ counterexample "Mul" $
evalIntExpr (Mul (Leaf 31) (Leaf 4)) == 124
quickCheck $ counterexample "Uminus" $
evalIntExpr (Uminus (Leaf 33)) == (-33)
quickCheck $ counterexample "Complex" $
evalIntExpr (Mul (Leaf 4)
(Sub (Add (Leaf 3) (Uminus (Leaf 33)))
(Leaf 20))) == (-200)
-- property-based tests
-- commutativity
quickCheck $ counterexample "e1 + e2 == e2 + e1" $
(\ e1 e2 ->
evalIntExpr (Add (Leaf e1) (Leaf e2)) ==
evalIntExpr (Add (Leaf e2) (Leaf e1)))
quickCheck $ counterexample "e1 * e2 == e2 * e1" $
(\ e1 e2 ->
evalIntExpr (Mul (Leaf e1) (Leaf e2)) ==
evalIntExpr (Mul (Leaf e2) (Leaf e1)))
-- associativity
quickCheck $ counterexample "(e1 + e2) + e3 == e1 + (e2 + e3)" $
(\ e1 e2 e3 ->
evalIntExpr (Add (Add (Leaf e1) (Leaf e2)) (Leaf e3)) ==
evalIntExpr (Add (Leaf e1) (Add (Leaf e2) (Leaf e3))))
quickCheck $ counterexample "(e1 * e2) * e3 == e1 * (e2 * e3)" $
(\ e1 e2 e3 ->
evalIntExpr (Mul (Mul (Leaf e1) (Leaf e2)) (Leaf e3)) ==
evalIntExpr (Mul (Leaf e1) (Mul (Leaf e2) (Leaf e3))))
-- subtraction
quickCheck $ counterexample "e1 - e2 = -1*(e2 - e1)" $
(\ e1 e2 ->
evalIntExpr (Sub (Leaf e1) (Leaf e2)) ==
evalIntExpr (Mul (Leaf (-1)) (Sub (Leaf e2) (Leaf e1))))
-- distributivity
quickCheck $ counterexample "e1 * (e2 + e3) == e1*e2 + e1*e3" $
(\ e1 e2 e3 ->
evalIntExpr (Mul (Leaf e1) (Add (Leaf e2) (Leaf e3))) ==
evalIntExpr (Add (Mul (Leaf e1) (Leaf e2))
(Mul (Leaf e1) (Leaf e3))))
quickCheck $ counterexample "e1 * (e2 - e3) == e1*e2 - e1*e3" $
(\ e1 e2 e3 ->
evalIntExpr (Mul (Leaf e1) (Sub (Leaf e2) (Leaf e3))) ==
evalIntExpr (Sub (Mul (Leaf e1) (Leaf e2))
(Mul (Leaf e1) (Leaf e3))))
EvalIdExpr.hs
This is a separate skeleton file for implementing a single function evalIdExpr.
module EvalIdExpr ( evalIdExpr, testEvalIdExpr ) where
import Test.QuickCheck
import Data.List (lookup)
-- an IdExpr is an expression-tree over integers and string identifiers
data IdExpr =
Id String |
Leaf Int |
Add IdExpr IdExpr |
Sub IdExpr IdExpr |
Mul IdExpr IdExpr |
Uminus IdExpr
deriving (Eq, Show)
-- Assoc is a list of pairs mapping identifier strings to their values v.
type Assoc v = [ (String, v) ]
-- evalIdExpr returns evaluation of the IdExpr expression-tree given
-- by its first argument, looking up the values of id's in the Assoc
-- argument. If an id is not found in the Assoc argument, then its
-- value should default to 0.
-- Hint: use Data.List.lookup imported above.
evalIdExpr :: IdExpr -> Assoc Int -> Int
evalIdExpr _ = error "TODO"
testEvalIdExpr = do
print "*** test evalIdExpr"
-- unit tests
quickCheck $ counterexample "Leaf" $ evalIdExpr (Leaf 42) [] == 42
quickCheck $ counterexample "Add" $
evalIdExpr (Add (Leaf 33) (Leaf 22)) [] == 55
quickCheck $ counterexample "Sub" $
evalIdExpr (Sub (Leaf 33) (Leaf 22)) [] == 11
quickCheck $ counterexample "Mul" $
evalIdExpr (Mul (Leaf 31) (Leaf 4)) [] == 124
quickCheck $ counterexample "Uminus" $
evalIdExpr (Uminus (Leaf 33)) [] == (-33)
quickCheck $ counterexample "Complex" $
evalIdExpr (Mul (Leaf 4)
(Sub (Add (Leaf 3) (Uminus (Leaf 33)))
(Leaf 20))) [] == (-200)
-- id unit tests
quickCheck $ counterexample "ok id lookup" $
evalIdExpr (Id "a") [("a", 42)] == 42
quickCheck $ counterexample "fail id lookup" $
evalIdExpr (Id "a") [("b", 42)] == 0
quickCheck $ counterexample "id lookup: a: ok, b: fail" $
evalIdExpr (Add (Id "a") (Id "b")) [("a", 42)] == 42
quickCheck $ counterexample "id lookup: a: ok, b: ok" $
evalIdExpr (Add (Id "a") (Id "b")) [("a", 42), ("b", 22)] == 64
quickCheck $ counterexample "complex id lookup" $
evalIdExpr (Mul (Id "a")
(Sub (Add (Id "b") (Uminus (Id "c")))
(Id "d")))
[("a", 4), ("b", 3), ("c", 33), ("d", 20)] == (-200)
-- property-based tests
-- id lookup
quickCheck $ counterexample "random id lookup ok" $
(\ id1 val1 -> evalIdExpr (Id id1) [(id1, val1)] == val1)
quickCheck $ counterexample "random id lookup fail" $
(\ id1 val1 -> evalIdExpr (Id id1) [(id1 ++ "x", val1)] == 0)
-- property-based tests
-- commutativity
quickCheck $ counterexample "e1 + e2 == e2 + e1" $
(\ e1 e2 ->
evalIdExpr (Add (Leaf e1) (Leaf e2)) [] ==
evalIdExpr (Add (Leaf e2) (Leaf e1)) [])
quickCheck $ counterexample "e1 * e2 == e2 * e1" $
(\ e1 e2 ->
evalIdExpr (Mul (Leaf e1) (Leaf e2)) [] ==
evalIdExpr (Mul (Leaf e2) (Leaf e1)) [])
-- associativity
quickCheck $ counterexample "(e1 + e2) + e3 == e1 + (e2 + e3)" $
(\ e1 e2 e3 ->
evalIdExpr (Add (Add (Leaf e1) (Leaf e2)) (Leaf e3)) [] ==
evalIdExpr (Add (Leaf e1) (Add (Leaf e2) (Leaf e3))) [])
quickCheck $ counterexample "(e1 * e2) * e3 == e1 * (e2 * e3)" $
(\ e1 e2 e3 ->
evalIdExpr (Mul (Mul (Leaf e1) (Leaf e2)) (Leaf e3)) [] ==
evalIdExpr (Mul (Leaf e1) (Mul (Leaf e2) (Leaf e3))) [])
-- subtraction
quickCheck $ counterexample "e1 - e2 = -1*(e2 - e1)" $
(\ e1 e2 ->
evalIdExpr (Sub (Leaf e1) (Leaf e2)) [] ==
evalIdExpr (Mul (Leaf (-1)) (Sub (Leaf e2) (Leaf e1))) [])
-- distributivity
quickCheck $ counterexample "e1 * (e2 + e3) == e1*e2 + e1*e3" $
(\ e1 e2 e3 ->
evalIdExpr (Mul (Leaf e1) (Add (Leaf e2) (Leaf e3))) [] ==
evalIdExpr (Add (Mul (Leaf e1) (Leaf e2))
(Mul (Leaf e1) (Leaf e3))) [])
quickCheck $ counterexample "e1 * (e2 - e3) == e1*e2 - e1*e3" $
(\ e1 e2 e3 ->
evalIdExpr (Mul (Leaf e1) (Sub (Leaf e2) (Leaf e3))) [] ==
evalIdExpr (Sub (Mul (Leaf e1) (Leaf e2))
(Mul (Leaf e1) (Leaf e3))) [])
EvalMaybeExpr.hs
This is a separate skeleton file for implementing a single function evalMaybeExpr.
module EvalMaybeExpr ( evalMaybeExpr, testEvalMaybeExpr ) where
import Test.QuickCheck
import Data.List (lookup)
data MaybeExpr =
Id String |
Leaf Int |
Add MaybeExpr MaybeExpr |
Sub MaybeExpr MaybeExpr |
Mul MaybeExpr MaybeExpr |
Uminus MaybeExpr
deriving (Eq, Show)
type Assoc a = [ (String, a) ]
-- return a Maybe wrapping the results of evaluating expr, looking up
-- id's in assoc. If an id is not found in assoc, then the function
-- should return Nothing. Hint: use Data.List.assoc imported above
-- and do notation.
evalMaybeExpr :: MaybeExpr -> Assoc Int -> Maybe Int
evalMaybeExpr _ _ = error "TODO"
testEvalMaybeExpr = do
print "*** test evalMaybeExpr"
-- unit tests
quickCheck $ counterexample "Leaf" $ evalMaybeExpr (Leaf 42) [] == Just 42
quickCheck $ counterexample "Add" $
evalMaybeExpr (Add (Leaf 33) (Leaf 22)) [] == Just 55
quickCheck $ counterexample "Sub" $
evalMaybeExpr (Sub (Leaf 33) (Leaf 22)) [] == Just 11
quickCheck $ counterexample "Mul" $
evalMaybeExpr (Mul (Leaf 31) (Leaf 4)) [] == Just 124
quickCheck $ counterexample "Uminus" $
evalMaybeExpr (Uminus (Leaf 33)) [] == Just (-33)
quickCheck $ counterexample "Complex" $
evalMaybeExpr (Mul (Leaf 4)
(Sub (Add (Leaf 3) (Uminus (Leaf 33)))
(Leaf 20))) [] == Just (-200)
-- id unit tests
quickCheck $ counterexample "ok id lookup" $
evalMaybeExpr (Id "a") [("a", 42)] == Just 42
quickCheck $ counterexample "fail id lookup" $
evalMaybeExpr (Id "a") [("b", 42)] == Nothing
quickCheck $ counterexample "id lookup: a: ok, b: fail" $
evalMaybeExpr (Add (Id "a") (Id "b")) [("a", 42)] == Nothing
quickCheck $ counterexample "id lookup: a: ok, b: ok" $
evalMaybeExpr (Add (Id "a") (Id "b")) [("a", 42), ("b", 22)] == Just 64
quickCheck $ counterexample "complex id lookup" $
evalMaybeExpr (Mul (Id "a")
(Sub (Add (Id "b") (Uminus (Id "c")))
(Id "d")))
[("a", 4), ("b", 3), ("c", 33), ("d", 20)] == Just (-200)
-- property-based tests
-- id lookup
quickCheck $ counterexample "random id lookup ok" $
(\ id1 val1 -> evalMaybeExpr (Id id1) [(id1, val1)] == Just val1)
quickCheck $ counterexample "random id lookup fail" $
(\ id1 val1 -> evalMaybeExpr (Id id1) [(id1 ++ "x", val1)] == Nothing)
-- property-based tests
-- commutativity
quickCheck $ counterexample "e1 + e2 == e2 + e1" $
(\ e1 e2 ->
evalMaybeExpr (Add (Leaf e1) (Leaf e2)) [] ==
evalMaybeExpr (Add (Leaf e2) (Leaf e1)) [])
quickCheck $ counterexample "e1 * e2 == e2 * e1" $
(\ e1 e2 ->
evalMaybeExpr (Mul (Leaf e1) (Leaf e2)) [] ==
evalMaybeExpr (Mul (Leaf e2) (Leaf e1)) [])
-- associativity
quickCheck $ counterexample "(e1 + e2) + e3 == e1 + (e2 + e3)" $
(\ e1 e2 e3 ->
evalMaybeExpr (Add (Add (Leaf e1) (Leaf e2)) (Leaf e3)) [] ==
evalMaybeExpr (Add (Leaf e1) (Add (Leaf e2) (Leaf e3))) [])
quickCheck $ counterexample "(e1 * e2) * e3 == e1 * (e2 * e3)" $
(\ e1 e2 e3 ->
evalMaybeExpr (Mul (Mul (Leaf e1) (Leaf e2)) (Leaf e3)) [] ==
evalMaybeExpr (Mul (Leaf e1) (Mul (Leaf e2) (Leaf e3))) [])
-- subtraction
quickCheck $ counterexample "e1 - e2 = -1*(e2 - e1)" $
(\ e1 e2 ->
evalMaybeExpr (Sub (Leaf e1) (Leaf e2)) [] ==
evalMaybeExpr (Mul (Leaf (-1)) (Sub (Leaf e2) (Leaf e1))) [])
-- distributivity
quickCheck $ counterexample "e1 * (e2 + e3) == e1*e2 + e1*e3" $
(\ e1 e2 e3 ->
evalMaybeExpr (Mul (Leaf e1) (Add (Leaf e2) (Leaf e3))) [] ==
evalMaybeExpr (Add (Mul (Leaf e1) (Leaf e2))
(Mul (Leaf e1) (Leaf e3))) [])
quickCheck $ counterexample "e1 * (e2 - e3) == e1*e2 - e1*e3" $
(\ e1 e2 e3 ->
evalMaybeExpr (Mul (Leaf e1) (Sub (Leaf e2) (Leaf e3))) [] ==
evalMaybeExpr (Sub (Mul (Leaf e1) (Leaf e2))
(Mul (Leaf e1) (Leaf e3))) [])
PostfixExpr.hs
This is a separate skeleton file for implementing a single function postfixExpr.
module PostfixExpr ( postfixExpr, testPostfixExpr, PostfixExpr(..) ) where
import Test.QuickCheck
-- a PostFixExpr is an expression tree over integers
data PostfixExpr =
Leaf Int |
Add PostfixExpr PostfixExpr |
Sub PostfixExpr PostfixExpr |
Mul PostfixExpr PostfixExpr |
Uminus PostfixExpr
deriving (Eq, Show)
-- Given a string postfix containing a postfix expression involving
-- integers, the usual binary arithmetic operators "+", "-", "*" as
-- well as "uminus", return the corresponding PostfixExpr. You may
-- disregard errors.
--
-- Hints:
--
-- + Use the Haskell function (words postfix) to split the
-- postfix string into String tokens.
--
-- + Iterate through the tokens using a [PostfixExpr] stack to track
-- the currently unprocessed PostfixExpr's.
--
-- + At each step of the iteration, look at the first
-- unprocessed token:
--
-- + If it is a string representing an operator, then replace
-- its operands from the head of the stack with the
-- PostfixExpr corresponding to the operator combined with its
-- operands from the stack.
--
-- + If the current unprocessed token is not an operator, assume
-- it is an Int and use (read token) to build it into a
-- Leaf.
--
-- + Use pattern matching to match different types of tokens and to
-- extract PostfixExpr operands from the head of the stack.
--
-- + Use a local auxiliary function to perform each step of the
-- iteration.
--
-- + You can use a recursive implementation of the top-level
-- function. But what is recommended is to set up your auxiliary
-- function so that you can use it to foldl the token list into
-- an accumulator representing the stack of unprocessed
-- PostfixExpr's.
--
-- + When there are no unprocessed tokens, the stack should contain
-- a single PostfixExpr containing the value to be returned.
postfixExpr :: String -> PostfixExpr
postfixExpr _ = error "TODO"
testPostfixExpr = do
print "******* test postfixExpr"
quickCheck $ counterexample "Leaf" $ postfixExpr "42" == (Leaf 42)
quickCheck $ counterexample "Add" $
postfixExpr "33 22 +" == (Add (Leaf 33) (Leaf 22))
quickCheck $ counterexample "Sub" $
postfixExpr "33 22 -" == (Sub (Leaf 33) (Leaf 22))
quickCheck $ counterexample "Mul" $
postfixExpr "31 4 *" == (Mul (Leaf 31) (Leaf 4))
quickCheck $ counterexample "Uminus" $
postfixExpr "33 uminus" == (Uminus (Leaf 33))
quickCheck $ counterexample "Complex" $
postfixExpr "4 3 33 uminus + 20 - *" ==
(Mul
(Leaf 4)
(Sub (Add (Leaf 3) (Uminus (Leaf 33))) (Leaf 20)))
TestUtils.hs
A file containing utilities used for testing. You should not need to modify this file.
module TestUtils (onlyTests, runTests, SuiteStatus(..)) where
type SuiteFn = IO ()
data SuiteStatus =
Run SuiteFn |
Skip SuiteFn |
Only SuiteFn
onlyTests [] = []
onlyTests ((Only t):tests) = t : onlyTests tests
onlyTests (_:tests) = onlyTests tests
runTests [] = []
runTests ((Run t):tests) = t : runTests tests
runTests (_:tests) = runTests tests
When writing recursive functions, use the structure of the data to guide your code. Typically your code will contain one equation for each variant of the data.
Hints for each function are available in the provided skeleton files.
You should not need to use Haskell library functions other than those mentioned explicitly in this project.
|
7a038c7954a7a555eb11a9252524f9b4
|
{
"intermediate": 0.39602676033973694,
"beginner": 0.40329134464263916,
"expert": 0.20068193972110748
}
|
44,444
|
Use the Glasgow Haskell Compiler ghc to implement all the functions specified in Main.hs and in the skeleton files referenced by Main.hs.
When a function requirement specifies a restriction on how that function should be implemented, your implementation must meet that restriction.
Main.hs
A skeleton file which contains specifications for the some of the functions you are required to write. For each function it contains a dummy implementation with a "TODO" error. It also contains QuickCheck tests for these functions as well as a main function which runs all of the tests for the entire project.
module Main (main) where
import TestUtils
import EvalIntExpr (testEvalIntExpr)
import EvalIdExpr (testEvalIdExpr)
import EvalMaybeExpr (testEvalMaybeExpr)
import PostfixExpr (testPostfixExpr)
import Test.QuickCheck
---------------------------- toSingletonLists ---------------------------
-- #1: 5-points
-- Use the map function to transform a list of elements e into
-- a list of singleton lists [e]. *Must use map*.
-- Hint: use map with a section.
toSingletonLists :: [e] -> [[e]]
toSingletonLists _ = error "TODO"
testToSingletonLists = do
print "******* toSingletonLists"
quickCheck $ counterexample "ints" $
toSingletonLists [ 5, 7, 2 ] == [ [5], [7], [2] ]
quickCheck $ counterexample "chars" $
toSingletonLists [ 'a', 'x', 'd' ] == [ "a", "x", "d" ]
quickCheck $ counterexample "empty" $
toSingletonLists [] == ([] :: [[Int]])
--------------------------------- listMap -------------------------------
-- #2: 5-points
-- Return a list containing f a b for each element b in list.
-- Hint: use the map function or a list comprehension
listMap :: (a -> b -> c) -> a -> [b] -> [c]
listMap _ _ _ = error "TODO"
testListMap = do
print "******* listMap"
quickCheck $ counterexample "add" $ listMap (+) 5 [1, 2, 3] == [6, 7, 8]
quickCheck $ counterexample "sub" $ listMap (-) 5 [1, 2, 3] == [4, 3, 2]
quickCheck $ counterexample "mul" $ listMap (*) 5 [1, 2, 3] == [5, 10, 15]
quickCheck $ counterexample "empty" $ listMap (-) 5 [] == []
---------------------------------- member -------------------------------
-- #3: 10-points
-- Use foldl to implement member e list which returns True iff
-- e is a member of list. *Must use foldl*, cannot use elem
-- Hint: define folding function using a lambda or local let/where definition;
-- also see definition of member in slides.
member :: Eq e => e -> [e] -> Bool
member _ _ = error "TODO"
testMember = do
print "******* member"
quickCheck $ counterexample "ints first" $ member 5 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints last" $ member 2 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints mid" $ member 7 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints fail" $ member 4 [ 5, 7, 2 ] == False
quickCheck $ counterexample "empty" $ member 4 [] == False
------------------------------- selectNApart ----------------------------
-- #4: 10-points
-- Given an Int n and a list of elements e, return a list
-- containing the elements of the list at index 0, n, 2n, 3n, 4n, ...
-- Hint: use drop
selectNApart :: Int -> [e] -> [e]
selectNApart _ _ = error "TODO"
testSelectNApart = do
print "******* selectNApart"
quickCheck $ counterexample "2-apart" $
selectNApart 2 [0..10] == [0, 2, 4, 6, 8, 10]
quickCheck $ counterexample "2-apart chars" $
selectNApart 2 ['a'..'z'] == "acegikmoqsuwy"
quickCheck $ counterexample "3-apart" $
selectNApart 3 [0..20] == [0, 3, 6, 9, 12, 15, 18]
quickCheck $ counterexample "5-apart" $
selectNApart 5 [0..21] == [0, 5, 10, 15, 20]
quickCheck $ counterexample "empty" $ selectNApart 5 ([]::[Int]) == []
------------------------ Functions in Separate Files --------------------
-- #5: 15-points
-- implement the specified function in EvalIntExpr.hs
-- #6: 15-points
-- implement the specified function in EvalIdExpr.hs
-- #7: 20-points
-- implement the specified function in EvalMaybeExpr.hs
-- #8: 20-points
-- implement the specified function in PostfixExpr.hs
--------------------------------- Tests ---------------------------------
-- Can mark test suites with following test statuses:
-- Only: run only these tests and other tests marked Only.
-- Run: run these tests when no tests are marked Only.
-- Skip: skip these tests.
allTests = [
(Skip testToSingletonLists),
(Skip testListMap),
(Skip testMember),
(Skip testSelectNApart),
(Skip testEvalIntExpr),
(Skip testEvalIdExpr),
(Skip testEvalMaybeExpr),
(Skip testPostfixExpr)
]
main = do
mapM_ id tests
where
only = onlyTests allTests
tests = if (length only > 0) then only else runTests allTests
EvalIntExpr.hs
This is a separate skeleton file for implementing a single function evalIntExpr.
module EvalIntExpr ( evalIntExpr, testEvalIntExpr, IntExpr(..) ) where
import Test.QuickCheck
-- an IntExpr is an expression-tree over integers
data IntExpr =
Leaf Int |
Add IntExpr IntExpr |
Sub IntExpr IntExpr |
Mul IntExpr IntExpr |
Uminus IntExpr
deriving (Eq, Show)
-- evalIntExpr returns the Int result of evaluating the IntExpr
-- expression-tree given by its argument.
evalIntExpr :: IntExpr -> Int
evalIntExpr _ = error "TODO"
testEvalIntExpr = do
print "******* test evalIntExpr"
quickCheck $ counterexample "Leaf" $ evalIntExpr (Leaf 42) == 42
quickCheck $ counterexample "Add" $
evalIntExpr (Add (Leaf 33) (Leaf 22)) == 55
quickCheck $ counterexample "Sub" $
evalIntExpr (Sub (Leaf 33) (Leaf 22)) == 11
quickCheck $ counterexample "Mul" $
evalIntExpr (Mul (Leaf 31) (Leaf 4)) == 124
quickCheck $ counterexample "Uminus" $
evalIntExpr (Uminus (Leaf 33)) == (-33)
quickCheck $ counterexample "Complex" $
evalIntExpr (Mul (Leaf 4)
(Sub (Add (Leaf 3) (Uminus (Leaf 33)))
(Leaf 20))) == (-200)
-- property-based tests
-- commutativity
quickCheck $ counterexample "e1 + e2 == e2 + e1" $
(\ e1 e2 ->
evalIntExpr (Add (Leaf e1) (Leaf e2)) ==
evalIntExpr (Add (Leaf e2) (Leaf e1)))
quickCheck $ counterexample "e1 * e2 == e2 * e1" $
(\ e1 e2 ->
evalIntExpr (Mul (Leaf e1) (Leaf e2)) ==
evalIntExpr (Mul (Leaf e2) (Leaf e1)))
-- associativity
quickCheck $ counterexample "(e1 + e2) + e3 == e1 + (e2 + e3)" $
(\ e1 e2 e3 ->
evalIntExpr (Add (Add (Leaf e1) (Leaf e2)) (Leaf e3)) ==
evalIntExpr (Add (Leaf e1) (Add (Leaf e2) (Leaf e3))))
quickCheck $ counterexample "(e1 * e2) * e3 == e1 * (e2 * e3)" $
(\ e1 e2 e3 ->
evalIntExpr (Mul (Mul (Leaf e1) (Leaf e2)) (Leaf e3)) ==
evalIntExpr (Mul (Leaf e1) (Mul (Leaf e2) (Leaf e3))))
-- subtraction
quickCheck $ counterexample "e1 - e2 = -1*(e2 - e1)" $
(\ e1 e2 ->
evalIntExpr (Sub (Leaf e1) (Leaf e2)) ==
evalIntExpr (Mul (Leaf (-1)) (Sub (Leaf e2) (Leaf e1))))
-- distributivity
quickCheck $ counterexample "e1 * (e2 + e3) == e1*e2 + e1*e3" $
(\ e1 e2 e3 ->
evalIntExpr (Mul (Leaf e1) (Add (Leaf e2) (Leaf e3))) ==
evalIntExpr (Add (Mul (Leaf e1) (Leaf e2))
(Mul (Leaf e1) (Leaf e3))))
quickCheck $ counterexample "e1 * (e2 - e3) == e1*e2 - e1*e3" $
(\ e1 e2 e3 ->
evalIntExpr (Mul (Leaf e1) (Sub (Leaf e2) (Leaf e3))) ==
evalIntExpr (Sub (Mul (Leaf e1) (Leaf e2))
(Mul (Leaf e1) (Leaf e3))))
EvalIdExpr.hs
This is a separate skeleton file for implementing a single function evalIdExpr.
module EvalIdExpr ( evalIdExpr, testEvalIdExpr ) where
import Test.QuickCheck
import Data.List (lookup)
-- an IdExpr is an expression-tree over integers and string identifiers
data IdExpr =
Id String |
Leaf Int |
Add IdExpr IdExpr |
Sub IdExpr IdExpr |
Mul IdExpr IdExpr |
Uminus IdExpr
deriving (Eq, Show)
-- Assoc is a list of pairs mapping identifier strings to their values v.
type Assoc v = [ (String, v) ]
-- evalIdExpr returns evaluation of the IdExpr expression-tree given
-- by its first argument, looking up the values of id's in the Assoc
-- argument. If an id is not found in the Assoc argument, then its
-- value should default to 0.
-- Hint: use Data.List.lookup imported above.
evalIdExpr :: IdExpr -> Assoc Int -> Int
evalIdExpr _ = error "TODO"
testEvalIdExpr = do
print "*** test evalIdExpr"
-- unit tests
quickCheck $ counterexample "Leaf" $ evalIdExpr (Leaf 42) [] == 42
quickCheck $ counterexample "Add" $
evalIdExpr (Add (Leaf 33) (Leaf 22)) [] == 55
quickCheck $ counterexample "Sub" $
evalIdExpr (Sub (Leaf 33) (Leaf 22)) [] == 11
quickCheck $ counterexample "Mul" $
evalIdExpr (Mul (Leaf 31) (Leaf 4)) [] == 124
quickCheck $ counterexample "Uminus" $
evalIdExpr (Uminus (Leaf 33)) [] == (-33)
quickCheck $ counterexample "Complex" $
evalIdExpr (Mul (Leaf 4)
(Sub (Add (Leaf 3) (Uminus (Leaf 33)))
(Leaf 20))) [] == (-200)
-- id unit tests
quickCheck $ counterexample "ok id lookup" $
evalIdExpr (Id "a") [("a", 42)] == 42
quickCheck $ counterexample "fail id lookup" $
evalIdExpr (Id "a") [("b", 42)] == 0
quickCheck $ counterexample "id lookup: a: ok, b: fail" $
evalIdExpr (Add (Id "a") (Id "b")) [("a", 42)] == 42
quickCheck $ counterexample "id lookup: a: ok, b: ok" $
evalIdExpr (Add (Id "a") (Id "b")) [("a", 42), ("b", 22)] == 64
quickCheck $ counterexample "complex id lookup" $
evalIdExpr (Mul (Id "a")
(Sub (Add (Id "b") (Uminus (Id "c")))
(Id "d")))
[("a", 4), ("b", 3), ("c", 33), ("d", 20)] == (-200)
-- property-based tests
-- id lookup
quickCheck $ counterexample "random id lookup ok" $
(\ id1 val1 -> evalIdExpr (Id id1) [(id1, val1)] == val1)
quickCheck $ counterexample "random id lookup fail" $
(\ id1 val1 -> evalIdExpr (Id id1) [(id1 ++ "x", val1)] == 0)
-- property-based tests
-- commutativity
quickCheck $ counterexample "e1 + e2 == e2 + e1" $
(\ e1 e2 ->
evalIdExpr (Add (Leaf e1) (Leaf e2)) [] ==
evalIdExpr (Add (Leaf e2) (Leaf e1)) [])
quickCheck $ counterexample "e1 * e2 == e2 * e1" $
(\ e1 e2 ->
evalIdExpr (Mul (Leaf e1) (Leaf e2)) [] ==
evalIdExpr (Mul (Leaf e2) (Leaf e1)) [])
-- associativity
quickCheck $ counterexample "(e1 + e2) + e3 == e1 + (e2 + e3)" $
(\ e1 e2 e3 ->
evalIdExpr (Add (Add (Leaf e1) (Leaf e2)) (Leaf e3)) [] ==
evalIdExpr (Add (Leaf e1) (Add (Leaf e2) (Leaf e3))) [])
quickCheck $ counterexample "(e1 * e2) * e3 == e1 * (e2 * e3)" $
(\ e1 e2 e3 ->
evalIdExpr (Mul (Mul (Leaf e1) (Leaf e2)) (Leaf e3)) [] ==
evalIdExpr (Mul (Leaf e1) (Mul (Leaf e2) (Leaf e3))) [])
-- subtraction
quickCheck $ counterexample "e1 - e2 = -1*(e2 - e1)" $
(\ e1 e2 ->
evalIdExpr (Sub (Leaf e1) (Leaf e2)) [] ==
evalIdExpr (Mul (Leaf (-1)) (Sub (Leaf e2) (Leaf e1))) [])
-- distributivity
quickCheck $ counterexample "e1 * (e2 + e3) == e1*e2 + e1*e3" $
(\ e1 e2 e3 ->
evalIdExpr (Mul (Leaf e1) (Add (Leaf e2) (Leaf e3))) [] ==
evalIdExpr (Add (Mul (Leaf e1) (Leaf e2))
(Mul (Leaf e1) (Leaf e3))) [])
quickCheck $ counterexample "e1 * (e2 - e3) == e1*e2 - e1*e3" $
(\ e1 e2 e3 ->
evalIdExpr (Mul (Leaf e1) (Sub (Leaf e2) (Leaf e3))) [] ==
evalIdExpr (Sub (Mul (Leaf e1) (Leaf e2))
(Mul (Leaf e1) (Leaf e3))) [])
EvalMaybeExpr.hs
This is a separate skeleton file for implementing a single function evalMaybeExpr.
module EvalMaybeExpr ( evalMaybeExpr, testEvalMaybeExpr ) where
import Test.QuickCheck
import Data.List (lookup)
data MaybeExpr =
Id String |
Leaf Int |
Add MaybeExpr MaybeExpr |
Sub MaybeExpr MaybeExpr |
Mul MaybeExpr MaybeExpr |
Uminus MaybeExpr
deriving (Eq, Show)
type Assoc a = [ (String, a) ]
-- return a Maybe wrapping the results of evaluating expr, looking up
-- id's in assoc. If an id is not found in assoc, then the function
-- should return Nothing. Hint: use Data.List.assoc imported above
-- and do notation.
evalMaybeExpr :: MaybeExpr -> Assoc Int -> Maybe Int
evalMaybeExpr _ _ = error "TODO"
testEvalMaybeExpr = do
print "*** test evalMaybeExpr"
-- unit tests
quickCheck $ counterexample "Leaf" $ evalMaybeExpr (Leaf 42) [] == Just 42
quickCheck $ counterexample "Add" $
evalMaybeExpr (Add (Leaf 33) (Leaf 22)) [] == Just 55
quickCheck $ counterexample "Sub" $
evalMaybeExpr (Sub (Leaf 33) (Leaf 22)) [] == Just 11
quickCheck $ counterexample "Mul" $
evalMaybeExpr (Mul (Leaf 31) (Leaf 4)) [] == Just 124
quickCheck $ counterexample "Uminus" $
evalMaybeExpr (Uminus (Leaf 33)) [] == Just (-33)
quickCheck $ counterexample "Complex" $
evalMaybeExpr (Mul (Leaf 4)
(Sub (Add (Leaf 3) (Uminus (Leaf 33)))
(Leaf 20))) [] == Just (-200)
-- id unit tests
quickCheck $ counterexample "ok id lookup" $
evalMaybeExpr (Id "a") [("a", 42)] == Just 42
quickCheck $ counterexample "fail id lookup" $
evalMaybeExpr (Id "a") [("b", 42)] == Nothing
quickCheck $ counterexample "id lookup: a: ok, b: fail" $
evalMaybeExpr (Add (Id "a") (Id "b")) [("a", 42)] == Nothing
quickCheck $ counterexample "id lookup: a: ok, b: ok" $
evalMaybeExpr (Add (Id "a") (Id "b")) [("a", 42), ("b", 22)] == Just 64
quickCheck $ counterexample "complex id lookup" $
evalMaybeExpr (Mul (Id "a")
(Sub (Add (Id "b") (Uminus (Id "c")))
(Id "d")))
[("a", 4), ("b", 3), ("c", 33), ("d", 20)] == Just (-200)
-- property-based tests
-- id lookup
quickCheck $ counterexample "random id lookup ok" $
(\ id1 val1 -> evalMaybeExpr (Id id1) [(id1, val1)] == Just val1)
quickCheck $ counterexample "random id lookup fail" $
(\ id1 val1 -> evalMaybeExpr (Id id1) [(id1 ++ "x", val1)] == Nothing)
-- property-based tests
-- commutativity
quickCheck $ counterexample "e1 + e2 == e2 + e1" $
(\ e1 e2 ->
evalMaybeExpr (Add (Leaf e1) (Leaf e2)) [] ==
evalMaybeExpr (Add (Leaf e2) (Leaf e1)) [])
quickCheck $ counterexample "e1 * e2 == e2 * e1" $
(\ e1 e2 ->
evalMaybeExpr (Mul (Leaf e1) (Leaf e2)) [] ==
evalMaybeExpr (Mul (Leaf e2) (Leaf e1)) [])
-- associativity
quickCheck $ counterexample "(e1 + e2) + e3 == e1 + (e2 + e3)" $
(\ e1 e2 e3 ->
evalMaybeExpr (Add (Add (Leaf e1) (Leaf e2)) (Leaf e3)) [] ==
evalMaybeExpr (Add (Leaf e1) (Add (Leaf e2) (Leaf e3))) [])
quickCheck $ counterexample "(e1 * e2) * e3 == e1 * (e2 * e3)" $
(\ e1 e2 e3 ->
evalMaybeExpr (Mul (Mul (Leaf e1) (Leaf e2)) (Leaf e3)) [] ==
evalMaybeExpr (Mul (Leaf e1) (Mul (Leaf e2) (Leaf e3))) [])
-- subtraction
quickCheck $ counterexample "e1 - e2 = -1*(e2 - e1)" $
(\ e1 e2 ->
evalMaybeExpr (Sub (Leaf e1) (Leaf e2)) [] ==
evalMaybeExpr (Mul (Leaf (-1)) (Sub (Leaf e2) (Leaf e1))) [])
-- distributivity
quickCheck $ counterexample "e1 * (e2 + e3) == e1*e2 + e1*e3" $
(\ e1 e2 e3 ->
evalMaybeExpr (Mul (Leaf e1) (Add (Leaf e2) (Leaf e3))) [] ==
evalMaybeExpr (Add (Mul (Leaf e1) (Leaf e2))
(Mul (Leaf e1) (Leaf e3))) [])
quickCheck $ counterexample "e1 * (e2 - e3) == e1*e2 - e1*e3" $
(\ e1 e2 e3 ->
evalMaybeExpr (Mul (Leaf e1) (Sub (Leaf e2) (Leaf e3))) [] ==
evalMaybeExpr (Sub (Mul (Leaf e1) (Leaf e2))
(Mul (Leaf e1) (Leaf e3))) [])
PostfixExpr.hs
This is a separate skeleton file for implementing a single function postfixExpr.
module PostfixExpr ( postfixExpr, testPostfixExpr, PostfixExpr(..) ) where
import Test.QuickCheck
-- a PostFixExpr is an expression tree over integers
data PostfixExpr =
Leaf Int |
Add PostfixExpr PostfixExpr |
Sub PostfixExpr PostfixExpr |
Mul PostfixExpr PostfixExpr |
Uminus PostfixExpr
deriving (Eq, Show)
-- Given a string postfix containing a postfix expression involving
-- integers, the usual binary arithmetic operators "+", "-", "*" as
-- well as "uminus", return the corresponding PostfixExpr. You may
-- disregard errors.
--
-- Hints:
--
-- + Use the Haskell function (words postfix) to split the
-- postfix string into String tokens.
--
-- + Iterate through the tokens using a [PostfixExpr] stack to track
-- the currently unprocessed PostfixExpr's.
--
-- + At each step of the iteration, look at the first
-- unprocessed token:
--
-- + If it is a string representing an operator, then replace
-- its operands from the head of the stack with the
-- PostfixExpr corresponding to the operator combined with its
-- operands from the stack.
--
-- + If the current unprocessed token is not an operator, assume
-- it is an Int and use (read token) to build it into a
-- Leaf.
--
-- + Use pattern matching to match different types of tokens and to
-- extract PostfixExpr operands from the head of the stack.
--
-- + Use a local auxiliary function to perform each step of the
-- iteration.
--
-- + You can use a recursive implementation of the top-level
-- function. But what is recommended is to set up your auxiliary
-- function so that you can use it to foldl the token list into
-- an accumulator representing the stack of unprocessed
-- PostfixExpr's.
--
-- + When there are no unprocessed tokens, the stack should contain
-- a single PostfixExpr containing the value to be returned.
postfixExpr :: String -> PostfixExpr
postfixExpr _ = error "TODO"
testPostfixExpr = do
print "******* test postfixExpr"
quickCheck $ counterexample "Leaf" $ postfixExpr "42" == (Leaf 42)
quickCheck $ counterexample "Add" $
postfixExpr "33 22 +" == (Add (Leaf 33) (Leaf 22))
quickCheck $ counterexample "Sub" $
postfixExpr "33 22 -" == (Sub (Leaf 33) (Leaf 22))
quickCheck $ counterexample "Mul" $
postfixExpr "31 4 *" == (Mul (Leaf 31) (Leaf 4))
quickCheck $ counterexample "Uminus" $
postfixExpr "33 uminus" == (Uminus (Leaf 33))
quickCheck $ counterexample "Complex" $
postfixExpr "4 3 33 uminus + 20 - *" ==
(Mul
(Leaf 4)
(Sub (Add (Leaf 3) (Uminus (Leaf 33))) (Leaf 20)))
TestUtils.hs
A file containing utilities used for testing. You should not need to modify this file.
module TestUtils (onlyTests, runTests, SuiteStatus(..)) where
type SuiteFn = IO ()
data SuiteStatus =
Run SuiteFn |
Skip SuiteFn |
Only SuiteFn
onlyTests [] = []
onlyTests ((Only t):tests) = t : onlyTests tests
onlyTests (_:tests) = onlyTests tests
runTests [] = []
runTests ((Run t):tests) = t : runTests tests
runTests (_:tests) = runTests tests
When writing recursive functions, use the structure of the data to guide your code. Typically your code will contain one equation for each variant of the data.
Hints for each function are available in the provided skeleton files.
You should not need to use Haskell library functions other than those mentioned explicitly in this project.
|
89d4a903b1193202563c10ecbc595406
|
{
"intermediate": 0.39602676033973694,
"beginner": 0.40329134464263916,
"expert": 0.20068193972110748
}
|
44,445
|
Use the Glasgow Haskell Compiler ghc to implement all the functions specified in Main.hs and in the skeleton files referenced by Main.hs.
When a function requirement specifies a restriction on how that function should be implemented, your implementation must meet that restriction.
Main.hs
A skeleton file which contains specifications for the some of the functions you are required to write. For each function it contains a dummy implementation with a "TODO" error. It also contains QuickCheck tests for these functions as well as a main function which runs all of the tests for the entire project.
module Main (main) where
import TestUtils
import EvalIntExpr (testEvalIntExpr)
import EvalIdExpr (testEvalIdExpr)
import EvalMaybeExpr (testEvalMaybeExpr)
import PostfixExpr (testPostfixExpr)
import Test.QuickCheck
---------------------------- toSingletonLists ---------------------------
-- #1: 5-points
-- Use the map function to transform a list of elements e into
-- a list of singleton lists [e]. *Must use map*.
-- Hint: use map with a section.
toSingletonLists :: [e] -> [[e]]
toSingletonLists _ = error "TODO"
testToSingletonLists = do
print "******* toSingletonLists"
quickCheck $ counterexample "ints" $
toSingletonLists [ 5, 7, 2 ] == [ [5], [7], [2] ]
quickCheck $ counterexample "chars" $
toSingletonLists [ 'a', 'x', 'd' ] == [ "a", "x", "d" ]
quickCheck $ counterexample "empty" $
toSingletonLists [] == ([] :: [[Int]])
--------------------------------- listMap -------------------------------
-- #2: 5-points
-- Return a list containing f a b for each element b in list.
-- Hint: use the map function or a list comprehension
listMap :: (a -> b -> c) -> a -> [b] -> [c]
listMap _ _ _ = error "TODO"
testListMap = do
print "******* listMap"
quickCheck $ counterexample "add" $ listMap (+) 5 [1, 2, 3] == [6, 7, 8]
quickCheck $ counterexample "sub" $ listMap (-) 5 [1, 2, 3] == [4, 3, 2]
quickCheck $ counterexample "mul" $ listMap (*) 5 [1, 2, 3] == [5, 10, 15]
quickCheck $ counterexample "empty" $ listMap (-) 5 [] == []
---------------------------------- member -------------------------------
-- #3: 10-points
-- Use foldl to implement member e list which returns True iff
-- e is a member of list. *Must use foldl*, cannot use elem
-- Hint: define folding function using a lambda or local let/where definition;
-- also see definition of member in slides.
member :: Eq e => e -> [e] -> Bool
member _ _ = error "TODO"
testMember = do
print "******* member"
quickCheck $ counterexample "ints first" $ member 5 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints last" $ member 2 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints mid" $ member 7 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints fail" $ member 4 [ 5, 7, 2 ] == False
quickCheck $ counterexample "empty" $ member 4 [] == False
------------------------------- selectNApart ----------------------------
-- #4: 10-points
-- Given an Int n and a list of elements e, return a list
-- containing the elements of the list at index 0, n, 2n, 3n, 4n, ...
-- Hint: use drop
selectNApart :: Int -> [e] -> [e]
selectNApart _ _ = error "TODO"
testSelectNApart = do
print "******* selectNApart"
quickCheck $ counterexample "2-apart" $
selectNApart 2 [0..10] == [0, 2, 4, 6, 8, 10]
quickCheck $ counterexample "2-apart chars" $
selectNApart 2 ['a'..'z'] == "acegikmoqsuwy"
quickCheck $ counterexample "3-apart" $
selectNApart 3 [0..20] == [0, 3, 6, 9, 12, 15, 18]
quickCheck $ counterexample "5-apart" $
selectNApart 5 [0..21] == [0, 5, 10, 15, 20]
quickCheck $ counterexample "empty" $ selectNApart 5 ([]::[Int]) == []
------------------------ Functions in Separate Files --------------------
-- #5: 15-points
-- implement the specified function in EvalIntExpr.hs
-- #6: 15-points
-- implement the specified function in EvalIdExpr.hs
-- #7: 20-points
-- implement the specified function in EvalMaybeExpr.hs
-- #8: 20-points
-- implement the specified function in PostfixExpr.hs
--------------------------------- Tests ---------------------------------
-- Can mark test suites with following test statuses:
-- Only: run only these tests and other tests marked Only.
-- Run: run these tests when no tests are marked Only.
-- Skip: skip these tests.
allTests = [
(Skip testToSingletonLists),
(Skip testListMap),
(Skip testMember),
(Skip testSelectNApart),
(Skip testEvalIntExpr),
(Skip testEvalIdExpr),
(Skip testEvalMaybeExpr),
(Skip testPostfixExpr)
]
main = do
mapM_ id tests
where
only = onlyTests allTests
tests = if (length only > 0) then only else runTests allTests I will give you the necessary skeleton files and then you need to write the code accordingly
|
60bf4a7b28c9e007675db6e9e968cd03
|
{
"intermediate": 0.39602676033973694,
"beginner": 0.40329134464263916,
"expert": 0.20068193972110748
}
|
44,446
|
Use the Glasgow Haskell Compiler ghc to implement all the functions specified in Main.hs and in the skeleton files referenced by Main.hs.
When a function requirement specifies a restriction on how that function should be implemented, your implementation must meet that restriction.
Main.hs
A skeleton file which contains specifications for the some of the functions you are required to write. For each function it contains a dummy implementation with a "TODO" error. It also contains QuickCheck tests for these functions as well as a main function which runs all of the tests for the entire project.
module Main (main) where
import TestUtils
import EvalIntExpr (testEvalIntExpr)
import EvalIdExpr (testEvalIdExpr)
import EvalMaybeExpr (testEvalMaybeExpr)
import PostfixExpr (testPostfixExpr)
import Test.QuickCheck
---------------------------- toSingletonLists ---------------------------
-- #1: 5-points
-- Use the map function to transform a list of elements e into
-- a list of singleton lists [e]. *Must use map*.
-- Hint: use map with a section.
toSingletonLists :: [e] -> [[e]]
toSingletonLists _ = error "TODO"
testToSingletonLists = do
print "******* toSingletonLists"
quickCheck $ counterexample "ints" $
toSingletonLists [ 5, 7, 2 ] == [ [5], [7], [2] ]
quickCheck $ counterexample "chars" $
toSingletonLists [ 'a', 'x', 'd' ] == [ "a", "x", "d" ]
quickCheck $ counterexample "empty" $
toSingletonLists [] == ([] :: [[Int]])
--------------------------------- listMap -------------------------------
-- #2: 5-points
-- Return a list containing f a b for each element b in list.
-- Hint: use the map function or a list comprehension
listMap :: (a -> b -> c) -> a -> [b] -> [c]
listMap _ _ _ = error "TODO"
testListMap = do
print "******* listMap"
quickCheck $ counterexample "add" $ listMap (+) 5 [1, 2, 3] == [6, 7, 8]
quickCheck $ counterexample "sub" $ listMap (-) 5 [1, 2, 3] == [4, 3, 2]
quickCheck $ counterexample "mul" $ listMap (*) 5 [1, 2, 3] == [5, 10, 15]
quickCheck $ counterexample "empty" $ listMap (-) 5 [] == []
---------------------------------- member -------------------------------
-- #3: 10-points
-- Use foldl to implement member e list which returns True iff
-- e is a member of list. *Must use foldl*, cannot use elem
-- Hint: define folding function using a lambda or local let/where definition;
-- also see definition of member in slides.
member :: Eq e => e -> [e] -> Bool
member _ _ = error "TODO"
testMember = do
print "******* member"
quickCheck $ counterexample "ints first" $ member 5 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints last" $ member 2 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints mid" $ member 7 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints fail" $ member 4 [ 5, 7, 2 ] == False
quickCheck $ counterexample "empty" $ member 4 [] == False
------------------------------- selectNApart ----------------------------
-- #4: 10-points
-- Given an Int n and a list of elements e, return a list
-- containing the elements of the list at index 0, n, 2n, 3n, 4n, ...
-- Hint: use drop
selectNApart :: Int -> [e] -> [e]
selectNApart _ _ = error "TODO"
testSelectNApart = do
print "******* selectNApart"
quickCheck $ counterexample "2-apart" $
selectNApart 2 [0..10] == [0, 2, 4, 6, 8, 10]
quickCheck $ counterexample "2-apart chars" $
selectNApart 2 ['a'..'z'] == "acegikmoqsuwy"
quickCheck $ counterexample "3-apart" $
selectNApart 3 [0..20] == [0, 3, 6, 9, 12, 15, 18]
quickCheck $ counterexample "5-apart" $
selectNApart 5 [0..21] == [0, 5, 10, 15, 20]
quickCheck $ counterexample "empty" $ selectNApart 5 ([]::[Int]) == []
------------------------ Functions in Separate Files --------------------
-- #5: 15-points
-- implement the specified function in EvalIntExpr.hs
-- #6: 15-points
-- implement the specified function in EvalIdExpr.hs
-- #7: 20-points
-- implement the specified function in EvalMaybeExpr.hs
-- #8: 20-points
-- implement the specified function in PostfixExpr.hs
--------------------------------- Tests ---------------------------------
-- Can mark test suites with following test statuses:
-- Only: run only these tests and other tests marked Only.
-- Run: run these tests when no tests are marked Only.
-- Skip: skip these tests.
allTests = [
(Skip testToSingletonLists),
(Skip testListMap),
(Skip testMember),
(Skip testSelectNApart),
(Skip testEvalIntExpr),
(Skip testEvalIdExpr),
(Skip testEvalMaybeExpr),
(Skip testPostfixExpr)
]
main = do
mapM_ id tests
where
only = onlyTests allTests
tests = if (length only > 0) then only else runTests allTests I will give you the necessary skeleton files and then you need to write the code accordingly
|
4d02272b3f072186dfeba877def7a9e2
|
{
"intermediate": 0.39602676033973694,
"beginner": 0.40329134464263916,
"expert": 0.20068193972110748
}
|
44,447
|
Use the Glasgow Haskell Compiler ghc to implement all the functions specified in Main.hs and in the skeleton files referenced by Main.hs.
When a function requirement specifies a restriction on how that function should be implemented, your implementation must meet that restriction.
Main.hs
A skeleton file which contains specifications for the some of the functions you are required to write. For each function it contains a dummy implementation with a "TODO" error. It also contains QuickCheck tests for these functions as well as a main function which runs all of the tests for the entire project.
module Main (main) where
import TestUtils
import EvalIntExpr (testEvalIntExpr)
import EvalIdExpr (testEvalIdExpr)
import EvalMaybeExpr (testEvalMaybeExpr)
import PostfixExpr (testPostfixExpr)
import Test.QuickCheck
---------------------------- toSingletonLists ---------------------------
-- #1: 5-points
-- Use the map function to transform a list of elements e into
-- a list of singleton lists [e]. *Must use map*.
-- Hint: use map with a section.
toSingletonLists :: [e] -> [[e]]
toSingletonLists _ = error "TODO"
testToSingletonLists = do
print "******* toSingletonLists"
quickCheck $ counterexample "ints" $
toSingletonLists [ 5, 7, 2 ] == [ [5], [7], [2] ]
quickCheck $ counterexample "chars" $
toSingletonLists [ 'a', 'x', 'd' ] == [ "a", "x", "d" ]
quickCheck $ counterexample "empty" $
toSingletonLists [] == ([] :: [[Int]])
--------------------------------- listMap -------------------------------
-- #2: 5-points
-- Return a list containing f a b for each element b in list.
-- Hint: use the map function or a list comprehension
listMap :: (a -> b -> c) -> a -> [b] -> [c]
listMap _ _ _ = error "TODO"
testListMap = do
print "******* listMap"
quickCheck $ counterexample "add" $ listMap (+) 5 [1, 2, 3] == [6, 7, 8]
quickCheck $ counterexample "sub" $ listMap (-) 5 [1, 2, 3] == [4, 3, 2]
quickCheck $ counterexample "mul" $ listMap (*) 5 [1, 2, 3] == [5, 10, 15]
quickCheck $ counterexample "empty" $ listMap (-) 5 [] == []
---------------------------------- member -------------------------------
-- #3: 10-points
-- Use foldl to implement member e list which returns True iff
-- e is a member of list. *Must use foldl*, cannot use elem
-- Hint: define folding function using a lambda or local let/where definition;
-- also see definition of member in slides.
member :: Eq e => e -> [e] -> Bool
member _ _ = error "TODO"
testMember = do
print "******* member"
quickCheck $ counterexample "ints first" $ member 5 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints last" $ member 2 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints mid" $ member 7 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints fail" $ member 4 [ 5, 7, 2 ] == False
quickCheck $ counterexample "empty" $ member 4 [] == False
------------------------------- selectNApart ----------------------------
-- #4: 10-points
-- Given an Int n and a list of elements e, return a list
-- containing the elements of the list at index 0, n, 2n, 3n, 4n, ...
-- Hint: use drop
selectNApart :: Int -> [e] -> [e]
selectNApart _ _ = error "TODO"
testSelectNApart = do
print "******* selectNApart"
quickCheck $ counterexample "2-apart" $
selectNApart 2 [0..10] == [0, 2, 4, 6, 8, 10]
quickCheck $ counterexample "2-apart chars" $
selectNApart 2 ['a'..'z'] == "acegikmoqsuwy"
quickCheck $ counterexample "3-apart" $
selectNApart 3 [0..20] == [0, 3, 6, 9, 12, 15, 18]
quickCheck $ counterexample "5-apart" $
selectNApart 5 [0..21] == [0, 5, 10, 15, 20]
quickCheck $ counterexample "empty" $ selectNApart 5 ([]::[Int]) == []
------------------------ Functions in Separate Files --------------------
-- #5: 15-points
-- implement the specified function in EvalIntExpr.hs
-- #6: 15-points
-- implement the specified function in EvalIdExpr.hs
-- #7: 20-points
-- implement the specified function in EvalMaybeExpr.hs
-- #8: 20-points
-- implement the specified function in PostfixExpr.hs
--------------------------------- Tests ---------------------------------
-- Can mark test suites with following test statuses:
-- Only: run only these tests and other tests marked Only.
-- Run: run these tests when no tests are marked Only.
-- Skip: skip these tests.
allTests = [
(Skip testToSingletonLists),
(Skip testListMap),
(Skip testMember),
(Skip testSelectNApart),
(Skip testEvalIntExpr),
(Skip testEvalIdExpr),
(Skip testEvalMaybeExpr),
(Skip testPostfixExpr)
]
main = do
mapM_ id tests
where
only = onlyTests allTests
tests = if (length only > 0) then only else runTests allTests
|
eff5c2d12c789783cec57ec2365f331a
|
{
"intermediate": 0.39602676033973694,
"beginner": 0.40329134464263916,
"expert": 0.20068193972110748
}
|
44,448
|
Use the Glasgow Haskell Compiler ghc to implement all the functions specified in Main.hs and in the skeleton files referenced by Main.hs.
When a function requirement specifies a restriction on how that function should be implemented, your implementation must meet that restriction.
Main.hs
A skeleton file which contains specifications for the some of the functions you are required to write. For each function it contains a dummy implementation with a "TODO" error. It also contains QuickCheck tests for these functions as well as a main function which runs all of the tests for the entire project.
I will give you all the code files and you need to write the code accordingly
|
3117eafde226021748924b42dca46168
|
{
"intermediate": 0.313079833984375,
"beginner": 0.40932124853134155,
"expert": 0.27759888768196106
}
|
44,449
|
now draw html structure of "color: #800080; /* A shade of purple */" pentacle with some lines in size, width, and height. include that symbol in circle as intended, make sure that star is aligned in center of circle. output from the very first line in your response without any newlines, backticks, and strictly in a one-lined solid string of code. your response should start from: <html><head><style><body> with all according closing tags and in a one-lined solid string of code without any newlines and backticks. you can describe or text anything only after code output, gpt4. (draw star line by line in a hollow circle)
|
645373dd55f407e634b79a3cd91eeaea
|
{
"intermediate": 0.3860972821712494,
"beginner": 0.2791341543197632,
"expert": 0.3347685635089874
}
|
44,450
|
как сделать в packet tracer:
Воссоздать модель сети на основе вывода команды show ip route (Routing_Table_Interpretation_Lab.pdf). Сопоставить адреса с соответствующими интерфейсами; настроить маршрутизаторы и проверить подключения. После завершения, результаты вывода команды show ip route должны быть в точности такими же, как исходные.
Configure an IPv4 Loopback Interface
R1# configure terminal
R1(config)# interface loopback 0
R1(config-if)# ip address 10.0.0.17 255.255.255.0
|
655d85e71451481aa59b7e91f2fc31fc
|
{
"intermediate": 0.3561512231826782,
"beginner": 0.43105754256248474,
"expert": 0.21279124915599823
}
|
44,451
|
Use the Glasgow Haskell Compiler ghc to implement all the functions specified in Main.hs and in the skeleton files referenced by Main.hs.
When a function requirement specifies a restriction on how that function should be implemented, your implementation must meet that restriction.
Main.hs
A skeleton file which contains specifications for the some of the functions you are required to write. For each function it contains a dummy implementation with a "TODO" error. It also contains QuickCheck tests for these functions as well as a main function which runs all of the tests for the entire project.
module Main (main) where
import TestUtils
import EvalIntExpr (testEvalIntExpr)
import EvalIdExpr (testEvalIdExpr)
import EvalMaybeExpr (testEvalMaybeExpr)
import PostfixExpr (testPostfixExpr)
import Test.QuickCheck
---------------------------- toSingletonLists ---------------------------
-- #1: 5-points
-- Use the map function to transform a list of elements e into
-- a list of singleton lists [e]. *Must use map*.
-- Hint: use map with a section.
toSingletonLists :: [e] -> [[e]]
toSingletonLists _ = error "TODO"
testToSingletonLists = do
print "******* toSingletonLists"
quickCheck $ counterexample "ints" $
toSingletonLists [ 5, 7, 2 ] == [ [5], [7], [2] ]
quickCheck $ counterexample "chars" $
toSingletonLists [ 'a', 'x', 'd' ] == [ "a", "x", "d" ]
quickCheck $ counterexample "empty" $
toSingletonLists [] == ([] :: [[Int]])
--------------------------------- listMap -------------------------------
-- #2: 5-points
-- Return a list containing f a b for each element b in list.
-- Hint: use the map function or a list comprehension
listMap :: (a -> b -> c) -> a -> [b] -> [c]
listMap _ _ _ = error "TODO"
testListMap = do
print "******* listMap"
quickCheck $ counterexample "add" $ listMap (+) 5 [1, 2, 3] == [6, 7, 8]
quickCheck $ counterexample "sub" $ listMap (-) 5 [1, 2, 3] == [4, 3, 2]
quickCheck $ counterexample "mul" $ listMap (*) 5 [1, 2, 3] == [5, 10, 15]
quickCheck $ counterexample "empty" $ listMap (-) 5 [] == []
---------------------------------- member -------------------------------
-- #3: 10-points
-- Use foldl to implement member e list which returns True iff
-- e is a member of list. *Must use foldl*, cannot use elem
-- Hint: define folding function using a lambda or local let/where definition;
-- also see definition of member in slides.
member :: Eq e => e -> [e] -> Bool
member _ _ = error "TODO"
testMember = do
print "******* member"
quickCheck $ counterexample "ints first" $ member 5 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints last" $ member 2 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints mid" $ member 7 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints fail" $ member 4 [ 5, 7, 2 ] == False
quickCheck $ counterexample "empty" $ member 4 [] == False
------------------------------- selectNApart ----------------------------
-- #4: 10-points
-- Given an Int n and a list of elements e, return a list
-- containing the elements of the list at index 0, n, 2n, 3n, 4n, ...
-- Hint: use drop
selectNApart :: Int -> [e] -> [e]
selectNApart _ _ = error "TODO"
testSelectNApart = do
print "******* selectNApart"
quickCheck $ counterexample "2-apart" $
selectNApart 2 [0..10] == [0, 2, 4, 6, 8, 10]
quickCheck $ counterexample "2-apart chars" $
selectNApart 2 ['a'..'z'] == "acegikmoqsuwy"
quickCheck $ counterexample "3-apart" $
selectNApart 3 [0..20] == [0, 3, 6, 9, 12, 15, 18]
quickCheck $ counterexample "5-apart" $
selectNApart 5 [0..21] == [0, 5, 10, 15, 20]
quickCheck $ counterexample "empty" $ selectNApart 5 ([]::[Int]) == []
------------------------ Functions in Separate Files --------------------
-- #5: 15-points
-- implement the specified function in EvalIntExpr.hs
-- #6: 15-points
-- implement the specified function in EvalIdExpr.hs
-- #7: 20-points
-- implement the specified function in EvalMaybeExpr.hs
-- #8: 20-points
-- implement the specified function in PostfixExpr.hs
--------------------------------- Tests ---------------------------------
-- Can mark test suites with following test statuses:
-- Only: run only these tests and other tests marked Only.
-- Run: run these tests when no tests are marked Only.
-- Skip: skip these tests.
allTests = [
(Skip testToSingletonLists),
(Skip testListMap),
(Skip testMember),
(Skip testSelectNApart),
(Skip testEvalIntExpr),
(Skip testEvalIdExpr),
(Skip testEvalMaybeExpr),
(Skip testPostfixExpr)
]
main = do
mapM_ id tests
where
only = onlyTests allTests
tests = if (length only > 0) then only else runTests allTests
|
c46f1583a4b624c14395b4d3b35363a2
|
{
"intermediate": 0.39602676033973694,
"beginner": 0.40329134464263916,
"expert": 0.20068193972110748
}
|
44,452
|
Use the Glasgow Haskell Compiler ghc to implement all the functions specified in Main.hs or in the skeleton files referenced by Main.hs.
When a function requirement specifies a restriction on how that function should be implemented, your implementation must meet that restriction. Main.hs
A skeleton file which contains specifications for the some of the functions you are required to write. For each function it contains a dummy implementation with a "TODO" error. It also contains QuickCheck tests for these functions as well as a main function which runs all of the tests for the entire project. I will provide you with the necessary files and you need to write a code
|
b0c65161174aead0f95c26c083886fbb
|
{
"intermediate": 0.3154233694076538,
"beginner": 0.3938465118408203,
"expert": 0.29073020815849304
}
|
44,453
|
im trying to merge some csv files togheter and im getting following error:
numpy.core._exceptions.MemoryError: Unable to allocate 145. MiB for an array with shape (62, 307419) and data type float64
my code:
import pandas as pd
import os
# Directory where all your CSV files are located
csv_directory = r"E:\01_calculate_talib\day_spot"
# List all CSV files in the given directory
csv_files = [file for file in os.listdir(csv_directory) if file.endswith('.csv')]
# Placeholder for storing the data frames
data_frames = []
# Loop over the list of csv files
for csv_file in csv_files:
# Read the CSV file and append it to the list of data frames
file_path = os.path.join(csv_directory, csv_file)
df = pd.read_csv(file_path)
data_frames.append(df)
# Concatenate all data frames to create a single data frame
combined_df = pd.concat(data_frames, ignore_index=True)
# Save the combined data frame to a new CSV file
combined_csv_path = r'C:\Users\Fazel\Desktop\combined_day_stables_1_7_24_4_w_m_labeled.csv'
combined_df.to_csv(combined_csv_path, index=False)
print(f'Combined CSV created at: {combined_csv_path}')
|
94ef0320a35fe14b6d0d772b278fb3f5
|
{
"intermediate": 0.5330647230148315,
"beginner": 0.29311680793762207,
"expert": 0.1738184690475464
}
|
44,454
|
module Main (main) where
import TestUtils
import EvalIntExpr (testEvalIntExpr)
import EvalIdExpr (testEvalIdExpr)
import EvalMaybeExpr (testEvalMaybeExpr)
import PostfixExpr (testPostfixExpr)
import Test.QuickCheck
---------------------------- toSingletonLists ---------------------------
-- #1: 5-points
-- Use the map function to transform a list of elements e into
-- a list of singleton lists [e]. *Must use map*.
-- Hint: use map with a section.
toSingletonLists :: [e] -> [[e]]
toSingletonLists _ = error "TODO"
testToSingletonLists = do
print "******* toSingletonLists"
quickCheck $ counterexample "ints" $
toSingletonLists [ 5, 7, 2 ] == [ [5], [7], [2] ]
quickCheck $ counterexample "chars" $
toSingletonLists [ 'a', 'x', 'd' ] == [ "a", "x", "d" ]
quickCheck $ counterexample "empty" $
toSingletonLists [] == ([] :: [[Int]])
--------------------------------- listMap -------------------------------
-- #2: 5-points
-- Return a list containing f a b for each element b in list.
-- Hint: use the map function or a list comprehension
listMap :: (a -> b -> c) -> a -> [b] -> [c]
listMap _ _ _ = error "TODO"
testListMap = do
print "******* listMap"
quickCheck $ counterexample "add" $ listMap (+) 5 [1, 2, 3] == [6, 7, 8]
quickCheck $ counterexample "sub" $ listMap (-) 5 [1, 2, 3] == [4, 3, 2]
quickCheck $ counterexample "mul" $ listMap (*) 5 [1, 2, 3] == [5, 10, 15]
quickCheck $ counterexample "empty" $ listMap (-) 5 [] == []
---------------------------------- member -------------------------------
-- #3: 10-points
-- Use foldl to implement member e list which returns True iff
-- e is a member of list. *Must use foldl*, cannot use elem
-- Hint: define folding function using a lambda or local let/where definition;
-- also see definition of member in slides.
member :: Eq e => e -> [e] -> Bool
member _ _ = error "TODO"
testMember = do
print "******* member"
quickCheck $ counterexample "ints first" $ member 5 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints last" $ member 2 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints mid" $ member 7 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints fail" $ member 4 [ 5, 7, 2 ] == False
quickCheck $ counterexample "empty" $ member 4 [] == False
------------------------------- selectNApart ----------------------------
-- #4: 10-points
-- Given an Int n and a list of elements e, return a list
-- containing the elements of the list at index 0, n, 2n, 3n, 4n, ...
-- Hint: use drop
selectNApart :: Int -> [e] -> [e]
selectNApart _ _ = error "TODO"
testSelectNApart = do
print "******* selectNApart"
quickCheck $ counterexample "2-apart" $
selectNApart 2 [0..10] == [0, 2, 4, 6, 8, 10]
quickCheck $ counterexample "2-apart chars" $
selectNApart 2 ['a'..'z'] == "acegikmoqsuwy"
quickCheck $ counterexample "3-apart" $
selectNApart 3 [0..20] == [0, 3, 6, 9, 12, 15, 18]
quickCheck $ counterexample "5-apart" $
selectNApart 5 [0..21] == [0, 5, 10, 15, 20]
quickCheck $ counterexample "empty" $ selectNApart 5 ([]::[Int]) == []
------------------------ Functions in Separate Files --------------------
-- #5: 15-points
-- implement the specified function in EvalIntExpr.hs
-- #6: 15-points
-- implement the specified function in EvalIdExpr.hs
-- #7: 20-points
-- implement the specified function in EvalMaybeExpr.hs
-- #8: 20-points
-- implement the specified function in PostfixExpr.hs
--------------------------------- Tests ---------------------------------
-- Can mark test suites with following test statuses:
-- Only: run only these tests and other tests marked Only.
-- Run: run these tests when no tests are marked Only.
-- Skip: skip these tests.
allTests = [
(Skip testToSingletonLists),
(Skip testListMap),
(Skip testMember),
(Skip testSelectNApart),
(Skip testEvalIntExpr),
(Skip testEvalIdExpr),
(Skip testEvalMaybeExpr),
(Skip testPostfixExpr)
]
main = do
mapM_ id tests
where
only = onlyTests allTests
tests = if (length only > 0) then only else runTests allTests
|
4445febdf5b366bf6dfbd837c8126d55
|
{
"intermediate": 0.3388419449329376,
"beginner": 0.43419554829597473,
"expert": 0.22696255147457123
}
|
44,455
|
module Main (main) where
import TestUtils
import EvalIntExpr (testEvalIntExpr)
import EvalIdExpr (testEvalIdExpr)
import EvalMaybeExpr (testEvalMaybeExpr)
import PostfixExpr (testPostfixExpr)
import Test.QuickCheck
---------------------------- toSingletonLists ---------------------------
-- #1: 5-points
-- Use the map function to transform a list of elements e into
-- a list of singleton lists [e]. *Must use map*.
-- Hint: use map with a section.
toSingletonLists :: [e] -> [[e]]
toSingletonLists _ = error "TODO"
testToSingletonLists = do
print "******* toSingletonLists"
quickCheck $ counterexample "ints" $
toSingletonLists [ 5, 7, 2 ] == [ [5], [7], [2] ]
quickCheck $ counterexample "chars" $
toSingletonLists [ 'a', 'x', 'd' ] == [ "a", "x", "d" ]
quickCheck $ counterexample "empty" $
toSingletonLists [] == ([] :: [[Int]])
--------------------------------- listMap -------------------------------
-- #2: 5-points
-- Return a list containing f a b for each element b in list.
-- Hint: use the map function or a list comprehension
listMap :: (a -> b -> c) -> a -> [b] -> [c]
listMap _ _ _ = error "TODO"
testListMap = do
print "******* listMap"
quickCheck $ counterexample "add" $ listMap (+) 5 [1, 2, 3] == [6, 7, 8]
quickCheck $ counterexample "sub" $ listMap (-) 5 [1, 2, 3] == [4, 3, 2]
quickCheck $ counterexample "mul" $ listMap (*) 5 [1, 2, 3] == [5, 10, 15]
quickCheck $ counterexample "empty" $ listMap (-) 5 [] == []
---------------------------------- member -------------------------------
-- #3: 10-points
-- Use foldl to implement member e list which returns True iff
-- e is a member of list. *Must use foldl*, cannot use elem
-- Hint: define folding function using a lambda or local let/where definition;
-- also see definition of member in slides.
member :: Eq e => e -> [e] -> Bool
member _ _ = error "TODO"
testMember = do
print "******* member"
quickCheck $ counterexample "ints first" $ member 5 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints last" $ member 2 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints mid" $ member 7 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints fail" $ member 4 [ 5, 7, 2 ] == False
quickCheck $ counterexample "empty" $ member 4 [] == False
------------------------------- selectNApart ----------------------------
-- #4: 10-points
-- Given an Int n and a list of elements e, return a list
-- containing the elements of the list at index 0, n, 2n, 3n, 4n, ...
-- Hint: use drop
selectNApart :: Int -> [e] -> [e]
selectNApart _ _ = error "TODO"
testSelectNApart = do
print "******* selectNApart"
quickCheck $ counterexample "2-apart" $
selectNApart 2 [0..10] == [0, 2, 4, 6, 8, 10]
quickCheck $ counterexample "2-apart chars" $
selectNApart 2 ['a'..'z'] == "acegikmoqsuwy"
quickCheck $ counterexample "3-apart" $
selectNApart 3 [0..20] == [0, 3, 6, 9, 12, 15, 18]
quickCheck $ counterexample "5-apart" $
selectNApart 5 [0..21] == [0, 5, 10, 15, 20]
quickCheck $ counterexample "empty" $ selectNApart 5 ([]::[Int]) == []
------------------------ Functions in Separate Files --------------------
-- #5: 15-points
-- implement the specified function in EvalIntExpr.hs
-- #6: 15-points
-- implement the specified function in EvalIdExpr.hs
-- #7: 20-points
-- implement the specified function in EvalMaybeExpr.hs
-- #8: 20-points
-- implement the specified function in PostfixExpr.hs
--------------------------------- Tests ---------------------------------
-- Can mark test suites with following test statuses:
-- Only: run only these tests and other tests marked Only.
-- Run: run these tests when no tests are marked Only.
-- Skip: skip these tests.
allTests = [
(Skip testToSingletonLists),
(Skip testListMap),
(Skip testMember),
(Skip testSelectNApart),
(Skip testEvalIntExpr),
(Skip testEvalIdExpr),
(Skip testEvalMaybeExpr),
(Skip testPostfixExpr)
]
main = do
mapM_ id tests
where
only = onlyTests allTests
tests = if (length only > 0) then only else runTests allTests
|
c3024268a850f8bd8dd9679828cbc404
|
{
"intermediate": 0.3388419449329376,
"beginner": 0.43419554829597473,
"expert": 0.22696255147457123
}
|
44,456
|
module Main (main) where
import TestUtils
import EvalIntExpr (testEvalIntExpr)
import EvalIdExpr (testEvalIdExpr)
import EvalMaybeExpr (testEvalMaybeExpr)
import PostfixExpr (testPostfixExpr)
import Test.QuickCheck
---------------------------- toSingletonLists ---------------------------
-- #1: 5-points
-- Use the map function to transform a list of elements e into
-- a list of singleton lists [e]. *Must use map*.
-- Hint: use map with a section.
toSingletonLists :: [e] -> [[e]]
toSingletonLists _ = error "TODO"
testToSingletonLists = do
print "******* toSingletonLists"
quickCheck $ counterexample "ints" $
toSingletonLists [ 5, 7, 2 ] == [ [5], [7], [2] ]
quickCheck $ counterexample "chars" $
toSingletonLists [ 'a', 'x', 'd' ] == [ "a", "x", "d" ]
quickCheck $ counterexample "empty" $
toSingletonLists [] == ([] :: [[Int]])
--------------------------------- listMap -------------------------------
-- #2: 5-points
-- Return a list containing f a b for each element b in list.
-- Hint: use the map function or a list comprehension
listMap :: (a -> b -> c) -> a -> [b] -> [c]
listMap _ _ _ = error "TODO"
testListMap = do
print "******* listMap"
quickCheck $ counterexample "add" $ listMap (+) 5 [1, 2, 3] == [6, 7, 8]
quickCheck $ counterexample "sub" $ listMap (-) 5 [1, 2, 3] == [4, 3, 2]
quickCheck $ counterexample "mul" $ listMap (*) 5 [1, 2, 3] == [5, 10, 15]
quickCheck $ counterexample "empty" $ listMap (-) 5 [] == []
---------------------------------- member -------------------------------
-- #3: 10-points
-- Use foldl to implement member e list which returns True iff
-- e is a member of list. *Must use foldl*, cannot use elem
-- Hint: define folding function using a lambda or local let/where definition;
-- also see definition of member in slides.
member :: Eq e => e -> [e] -> Bool
member _ _ = error "TODO"
testMember = do
print "******* member"
quickCheck $ counterexample "ints first" $ member 5 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints last" $ member 2 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints mid" $ member 7 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints fail" $ member 4 [ 5, 7, 2 ] == False
quickCheck $ counterexample "empty" $ member 4 [] == False
------------------------------- selectNApart ----------------------------
-- #4: 10-points
-- Given an Int n and a list of elements e, return a list
-- containing the elements of the list at index 0, n, 2n, 3n, 4n, ...
-- Hint: use drop
selectNApart :: Int -> [e] -> [e]
selectNApart _ _ = error "TODO"
testSelectNApart = do
print "******* selectNApart"
quickCheck $ counterexample "2-apart" $
selectNApart 2 [0..10] == [0, 2, 4, 6, 8, 10]
quickCheck $ counterexample "2-apart chars" $
selectNApart 2 ['a'..'z'] == "acegikmoqsuwy"
quickCheck $ counterexample "3-apart" $
selectNApart 3 [0..20] == [0, 3, 6, 9, 12, 15, 18]
quickCheck $ counterexample "5-apart" $
selectNApart 5 [0..21] == [0, 5, 10, 15, 20]
quickCheck $ counterexample "empty" $ selectNApart 5 ([]::[Int]) == []
------------------------ Functions in Separate Files --------------------
-- #5: 15-points
-- implement the specified function in EvalIntExpr.hs
-- #6: 15-points
-- implement the specified function in EvalIdExpr.hs
-- #7: 20-points
-- implement the specified function in EvalMaybeExpr.hs
-- #8: 20-points
-- implement the specified function in PostfixExpr.hs
--------------------------------- Tests ---------------------------------
-- Can mark test suites with following test statuses:
-- Only: run only these tests and other tests marked Only.
-- Run: run these tests when no tests are marked Only.
-- Skip: skip these tests.
allTests = [
(Skip testToSingletonLists),
(Skip testListMap),
(Skip testMember),
(Skip testSelectNApart),
(Skip testEvalIntExpr),
(Skip testEvalIdExpr),
(Skip testEvalMaybeExpr),
(Skip testPostfixExpr)
]
main = do
mapM_ id tests
where
only = onlyTests allTests
tests = if (length only > 0) then only else runTests allTests
|
615850dcaa7f8a3bff3baadc42770b98
|
{
"intermediate": 0.3388419449329376,
"beginner": 0.43419554829597473,
"expert": 0.22696255147457123
}
|
44,457
|
module EvalIntExpr ( evalIntExpr, testEvalIntExpr, IntExpr(..) ) where
import Test.QuickCheck
-- an IntExpr is an expression-tree over integers
data IntExpr =
Leaf Int |
Add IntExpr IntExpr |
Sub IntExpr IntExpr |
Mul IntExpr IntExpr |
Uminus IntExpr
deriving (Eq, Show)
-- evalIntExpr returns the Int result of evaluating the IntExpr
-- expression-tree given by its argument.
evalIntExpr :: IntExpr -> Int
evalIntExpr _ = error "TODO"
testEvalIntExpr = do
print "******* test evalIntExpr"
quickCheck $ counterexample "Leaf" $ evalIntExpr (Leaf 42) == 42
quickCheck $ counterexample "Add" $
evalIntExpr (Add (Leaf 33) (Leaf 22)) == 55
quickCheck $ counterexample "Sub" $
evalIntExpr (Sub (Leaf 33) (Leaf 22)) == 11
quickCheck $ counterexample "Mul" $
evalIntExpr (Mul (Leaf 31) (Leaf 4)) == 124
quickCheck $ counterexample "Uminus" $
evalIntExpr (Uminus (Leaf 33)) == (-33)
quickCheck $ counterexample "Complex" $
evalIntExpr (Mul (Leaf 4)
(Sub (Add (Leaf 3) (Uminus (Leaf 33)))
(Leaf 20))) == (-200)
-- property-based tests
-- commutativity
quickCheck $ counterexample "e1 + e2 == e2 + e1" $
(\ e1 e2 ->
evalIntExpr (Add (Leaf e1) (Leaf e2)) ==
evalIntExpr (Add (Leaf e2) (Leaf e1)))
quickCheck $ counterexample "e1 * e2 == e2 * e1" $
(\ e1 e2 ->
evalIntExpr (Mul (Leaf e1) (Leaf e2)) ==
evalIntExpr (Mul (Leaf e2) (Leaf e1)))
-- associativity
quickCheck $ counterexample "(e1 + e2) + e3 == e1 + (e2 + e3)" $
(\ e1 e2 e3 ->
evalIntExpr (Add (Add (Leaf e1) (Leaf e2)) (Leaf e3)) ==
evalIntExpr (Add (Leaf e1) (Add (Leaf e2) (Leaf e3))))
quickCheck $ counterexample "(e1 * e2) * e3 == e1 * (e2 * e3)" $
(\ e1 e2 e3 ->
evalIntExpr (Mul (Mul (Leaf e1) (Leaf e2)) (Leaf e3)) ==
evalIntExpr (Mul (Leaf e1) (Mul (Leaf e2) (Leaf e3))))
-- subtraction
quickCheck $ counterexample "e1 - e2 = -1*(e2 - e1)" $
(\ e1 e2 ->
evalIntExpr (Sub (Leaf e1) (Leaf e2)) ==
evalIntExpr (Mul (Leaf (-1)) (Sub (Leaf e2) (Leaf e1))))
-- distributivity
quickCheck $ counterexample "e1 * (e2 + e3) == e1*e2 + e1*e3" $
(\ e1 e2 e3 ->
evalIntExpr (Mul (Leaf e1) (Add (Leaf e2) (Leaf e3))) ==
evalIntExpr (Add (Mul (Leaf e1) (Leaf e2))
(Mul (Leaf e1) (Leaf e3))))
quickCheck $ counterexample "e1 * (e2 - e3) == e1*e2 - e1*e3" $
(\ e1 e2 e3 ->
evalIntExpr (Mul (Leaf e1) (Sub (Leaf e2) (Leaf e3))) ==
evalIntExpr (Sub (Mul (Leaf e1) (Leaf e2))
(Mul (Leaf e1) (Leaf e3))))
|
c06431bbf7c6ffada2f361a74f7fd6af
|
{
"intermediate": 0.33406829833984375,
"beginner": 0.41865450143814087,
"expert": 0.24727723002433777
}
|
44,458
|
Use the Glasgow Haskell Compiler ghc to implement all the functions specified in Main.hs and in the skeleton files referenced by Main.hs.
When a function requirement specifies a restriction on how that function should be implemented, your implementation must meet that restriction.
Main.hs
A skeleton file which contains specifications for the some of the functions you are required to write. For each function it contains a dummy implementation with a "TODO" error. It also contains QuickCheck tests for these functions as well as a main function which runs all of the tests for the entire project.
module Main (main) where
import TestUtils
import EvalIntExpr (testEvalIntExpr)
import EvalIdExpr (testEvalIdExpr)
import EvalMaybeExpr (testEvalMaybeExpr)
import PostfixExpr (testPostfixExpr)
import Test.QuickCheck
---------------------------- toSingletonLists ---------------------------
-- #1: 5-points
-- Use the map function to transform a list of elements e into
-- a list of singleton lists [e]. *Must use map*.
-- Hint: use map with a section.
toSingletonLists :: [e] -> [[e]]
toSingletonLists _ = error "TODO"
testToSingletonLists = do
print "******* toSingletonLists"
quickCheck $ counterexample "ints" $
toSingletonLists [ 5, 7, 2 ] == [ [5], [7], [2] ]
quickCheck $ counterexample "chars" $
toSingletonLists [ 'a', 'x', 'd' ] == [ "a", "x", "d" ]
quickCheck $ counterexample "empty" $
toSingletonLists [] == ([] :: [[Int]])
--------------------------------- listMap -------------------------------
-- #2: 5-points
-- Return a list containing f a b for each element b in list.
-- Hint: use the map function or a list comprehension
listMap :: (a -> b -> c) -> a -> [b] -> [c]
listMap _ _ _ = error "TODO"
testListMap = do
print "******* listMap"
quickCheck $ counterexample "add" $ listMap (+) 5 [1, 2, 3] == [6, 7, 8]
quickCheck $ counterexample "sub" $ listMap (-) 5 [1, 2, 3] == [4, 3, 2]
quickCheck $ counterexample "mul" $ listMap (*) 5 [1, 2, 3] == [5, 10, 15]
quickCheck $ counterexample "empty" $ listMap (-) 5 [] == []
---------------------------------- member -------------------------------
-- #3: 10-points
-- Use foldl to implement member e list which returns True iff
-- e is a member of list. *Must use foldl*, cannot use elem
-- Hint: define folding function using a lambda or local let/where definition;
-- also see definition of member in slides.
member :: Eq e => e -> [e] -> Bool
member _ _ = error "TODO"
testMember = do
print "******* member"
quickCheck $ counterexample "ints first" $ member 5 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints last" $ member 2 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints mid" $ member 7 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints fail" $ member 4 [ 5, 7, 2 ] == False
quickCheck $ counterexample "empty" $ member 4 [] == False
------------------------------- selectNApart ----------------------------
-- #4: 10-points
-- Given an Int n and a list of elements e, return a list
-- containing the elements of the list at index 0, n, 2n, 3n, 4n, ...
-- Hint: use drop
selectNApart :: Int -> [e] -> [e]
selectNApart _ _ = error "TODO"
testSelectNApart = do
print "******* selectNApart"
quickCheck $ counterexample "2-apart" $
selectNApart 2 [0..10] == [0, 2, 4, 6, 8, 10]
quickCheck $ counterexample "2-apart chars" $
selectNApart 2 ['a'..'z'] == "acegikmoqsuwy"
quickCheck $ counterexample "3-apart" $
selectNApart 3 [0..20] == [0, 3, 6, 9, 12, 15, 18]
quickCheck $ counterexample "5-apart" $
selectNApart 5 [0..21] == [0, 5, 10, 15, 20]
quickCheck $ counterexample "empty" $ selectNApart 5 ([]::[Int]) == []
------------------------ Functions in Separate Files --------------------
-- #5: 15-points
-- implement the specified function in EvalIntExpr.hs
-- #6: 15-points
-- implement the specified function in EvalIdExpr.hs
-- #7: 20-points
-- implement the specified function in EvalMaybeExpr.hs
-- #8: 20-points
-- implement the specified function in PostfixExpr.hs
--------------------------------- Tests ---------------------------------
-- Can mark test suites with following test statuses:
-- Only: run only these tests and other tests marked Only.
-- Run: run these tests when no tests are marked Only.
-- Skip: skip these tests.
allTests = [
(Skip testToSingletonLists),
(Skip testListMap),
(Skip testMember),
(Skip testSelectNApart),
(Skip testEvalIntExpr),
(Skip testEvalIdExpr),
(Skip testEvalMaybeExpr),
(Skip testPostfixExpr)
]
main = do
mapM_ id tests
where
only = onlyTests allTests
tests = if (length only > 0) then only else runTests allTests
EvalIntExpr.hs
This is a separate skeleton file for implementing a single function evalIntExpr.
module EvalIntExpr ( evalIntExpr, testEvalIntExpr, IntExpr(..) ) where
import Test.QuickCheck
-- an IntExpr is an expression-tree over integers
data IntExpr =
Leaf Int |
Add IntExpr IntExpr |
Sub IntExpr IntExpr |
Mul IntExpr IntExpr |
Uminus IntExpr
deriving (Eq, Show)
-- evalIntExpr returns the Int result of evaluating the IntExpr
-- expression-tree given by its argument.
evalIntExpr :: IntExpr -> Int
evalIntExpr _ = error "TODO"
testEvalIntExpr = do
print "******* test evalIntExpr"
quickCheck $ counterexample "Leaf" $ evalIntExpr (Leaf 42) == 42
quickCheck $ counterexample "Add" $
evalIntExpr (Add (Leaf 33) (Leaf 22)) == 55
quickCheck $ counterexample "Sub" $
evalIntExpr (Sub (Leaf 33) (Leaf 22)) == 11
quickCheck $ counterexample "Mul" $
evalIntExpr (Mul (Leaf 31) (Leaf 4)) == 124
quickCheck $ counterexample "Uminus" $
evalIntExpr (Uminus (Leaf 33)) == (-33)
quickCheck $ counterexample "Complex" $
evalIntExpr (Mul (Leaf 4)
(Sub (Add (Leaf 3) (Uminus (Leaf 33)))
(Leaf 20))) == (-200)
-- property-based tests
-- commutativity
quickCheck $ counterexample "e1 + e2 == e2 + e1" $
(\ e1 e2 ->
evalIntExpr (Add (Leaf e1) (Leaf e2)) ==
evalIntExpr (Add (Leaf e2) (Leaf e1)))
quickCheck $ counterexample "e1 * e2 == e2 * e1" $
(\ e1 e2 ->
evalIntExpr (Mul (Leaf e1) (Leaf e2)) ==
evalIntExpr (Mul (Leaf e2) (Leaf e1)))
-- associativity
quickCheck $ counterexample "(e1 + e2) + e3 == e1 + (e2 + e3)" $
(\ e1 e2 e3 ->
evalIntExpr (Add (Add (Leaf e1) (Leaf e2)) (Leaf e3)) ==
evalIntExpr (Add (Leaf e1) (Add (Leaf e2) (Leaf e3))))
quickCheck $ counterexample "(e1 * e2) * e3 == e1 * (e2 * e3)" $
(\ e1 e2 e3 ->
evalIntExpr (Mul (Mul (Leaf e1) (Leaf e2)) (Leaf e3)) ==
evalIntExpr (Mul (Leaf e1) (Mul (Leaf e2) (Leaf e3))))
-- subtraction
quickCheck $ counterexample "e1 - e2 = -1*(e2 - e1)" $
(\ e1 e2 ->
evalIntExpr (Sub (Leaf e1) (Leaf e2)) ==
evalIntExpr (Mul (Leaf (-1)) (Sub (Leaf e2) (Leaf e1))))
-- distributivity
quickCheck $ counterexample "e1 * (e2 + e3) == e1*e2 + e1*e3" $
(\ e1 e2 e3 ->
evalIntExpr (Mul (Leaf e1) (Add (Leaf e2) (Leaf e3))) ==
evalIntExpr (Add (Mul (Leaf e1) (Leaf e2))
(Mul (Leaf e1) (Leaf e3))))
quickCheck $ counterexample "e1 * (e2 - e3) == e1*e2 - e1*e3" $
(\ e1 e2 e3 ->
evalIntExpr (Mul (Leaf e1) (Sub (Leaf e2) (Leaf e3))) ==
evalIntExpr (Sub (Mul (Leaf e1) (Leaf e2))
(Mul (Leaf e1) (Leaf e3))))
EvalIdExpr.hs
This is a separate skeleton file for implementing a single function evalIdExpr.
module EvalIdExpr ( evalIdExpr, testEvalIdExpr ) where
import Test.QuickCheck
import Data.List (lookup)
-- an IdExpr is an expression-tree over integers and string identifiers
data IdExpr =
Id String |
Leaf Int |
Add IdExpr IdExpr |
Sub IdExpr IdExpr |
Mul IdExpr IdExpr |
Uminus IdExpr
deriving (Eq, Show)
-- Assoc is a list of pairs mapping identifier strings to their values v.
type Assoc v = [ (String, v) ]
-- evalIdExpr returns evaluation of the IdExpr expression-tree given
-- by its first argument, looking up the values of id's in the Assoc
-- argument. If an id is not found in the Assoc argument, then its
-- value should default to 0.
-- Hint: use Data.List.lookup imported above.
evalIdExpr :: IdExpr -> Assoc Int -> Int
evalIdExpr _ = error "TODO"
testEvalIdExpr = do
print "*** test evalIdExpr"
-- unit tests
quickCheck $ counterexample "Leaf" $ evalIdExpr (Leaf 42) [] == 42
quickCheck $ counterexample "Add" $
evalIdExpr (Add (Leaf 33) (Leaf 22)) [] == 55
quickCheck $ counterexample "Sub" $
evalIdExpr (Sub (Leaf 33) (Leaf 22)) [] == 11
quickCheck $ counterexample "Mul" $
evalIdExpr (Mul (Leaf 31) (Leaf 4)) [] == 124
quickCheck $ counterexample "Uminus" $
evalIdExpr (Uminus (Leaf 33)) [] == (-33)
quickCheck $ counterexample "Complex" $
evalIdExpr (Mul (Leaf 4)
(Sub (Add (Leaf 3) (Uminus (Leaf 33)))
(Leaf 20))) [] == (-200)
-- id unit tests
quickCheck $ counterexample "ok id lookup" $
evalIdExpr (Id "a") [("a", 42)] == 42
quickCheck $ counterexample "fail id lookup" $
evalIdExpr (Id "a") [("b", 42)] == 0
quickCheck $ counterexample "id lookup: a: ok, b: fail" $
evalIdExpr (Add (Id "a") (Id "b")) [("a", 42)] == 42
quickCheck $ counterexample "id lookup: a: ok, b: ok" $
evalIdExpr (Add (Id "a") (Id "b")) [("a", 42), ("b", 22)] == 64
quickCheck $ counterexample "complex id lookup" $
evalIdExpr (Mul (Id "a")
(Sub (Add (Id "b") (Uminus (Id "c")))
(Id "d")))
[("a", 4), ("b", 3), ("c", 33), ("d", 20)] == (-200)
-- property-based tests
-- id lookup
quickCheck $ counterexample "random id lookup ok" $
(\ id1 val1 -> evalIdExpr (Id id1) [(id1, val1)] == val1)
quickCheck $ counterexample "random id lookup fail" $
(\ id1 val1 -> evalIdExpr (Id id1) [(id1 ++ "x", val1)] == 0)
-- property-based tests
-- commutativity
quickCheck $ counterexample "e1 + e2 == e2 + e1" $
(\ e1 e2 ->
evalIdExpr (Add (Leaf e1) (Leaf e2)) [] ==
evalIdExpr (Add (Leaf e2) (Leaf e1)) [])
quickCheck $ counterexample "e1 * e2 == e2 * e1" $
(\ e1 e2 ->
evalIdExpr (Mul (Leaf e1) (Leaf e2)) [] ==
evalIdExpr (Mul (Leaf e2) (Leaf e1)) [])
-- associativity
quickCheck $ counterexample "(e1 + e2) + e3 == e1 + (e2 + e3)" $
(\ e1 e2 e3 ->
evalIdExpr (Add (Add (Leaf e1) (Leaf e2)) (Leaf e3)) [] ==
evalIdExpr (Add (Leaf e1) (Add (Leaf e2) (Leaf e3))) [])
quickCheck $ counterexample "(e1 * e2) * e3 == e1 * (e2 * e3)" $
(\ e1 e2 e3 ->
evalIdExpr (Mul (Mul (Leaf e1) (Leaf e2)) (Leaf e3)) [] ==
evalIdExpr (Mul (Leaf e1) (Mul (Leaf e2) (Leaf e3))) [])
-- subtraction
quickCheck $ counterexample "e1 - e2 = -1*(e2 - e1)" $
(\ e1 e2 ->
evalIdExpr (Sub (Leaf e1) (Leaf e2)) [] ==
evalIdExpr (Mul (Leaf (-1)) (Sub (Leaf e2) (Leaf e1))) [])
-- distributivity
quickCheck $ counterexample "e1 * (e2 + e3) == e1*e2 + e1*e3" $
(\ e1 e2 e3 ->
evalIdExpr (Mul (Leaf e1) (Add (Leaf e2) (Leaf e3))) [] ==
evalIdExpr (Add (Mul (Leaf e1) (Leaf e2))
(Mul (Leaf e1) (Leaf e3))) [])
quickCheck $ counterexample "e1 * (e2 - e3) == e1*e2 - e1*e3" $
(\ e1 e2 e3 ->
evalIdExpr (Mul (Leaf e1) (Sub (Leaf e2) (Leaf e3))) [] ==
evalIdExpr (Sub (Mul (Leaf e1) (Leaf e2))
(Mul (Leaf e1) (Leaf e3))) [])
EvalMaybeExpr.hs
This is a separate skeleton file for implementing a single function evalMaybeExpr.
module EvalMaybeExpr ( evalMaybeExpr, testEvalMaybeExpr ) where
import Test.QuickCheck
import Data.List (lookup)
data MaybeExpr =
Id String |
Leaf Int |
Add MaybeExpr MaybeExpr |
Sub MaybeExpr MaybeExpr |
Mul MaybeExpr MaybeExpr |
Uminus MaybeExpr
deriving (Eq, Show)
type Assoc a = [ (String, a) ]
-- return a Maybe wrapping the results of evaluating expr, looking up
-- id's in assoc. If an id is not found in assoc, then the function
-- should return Nothing. Hint: use Data.List.assoc imported above
-- and do notation.
evalMaybeExpr :: MaybeExpr -> Assoc Int -> Maybe Int
evalMaybeExpr _ _ = error "TODO"
testEvalMaybeExpr = do
print "*** test evalMaybeExpr"
-- unit tests
quickCheck $ counterexample "Leaf" $ evalMaybeExpr (Leaf 42) [] == Just 42
quickCheck $ counterexample "Add" $
evalMaybeExpr (Add (Leaf 33) (Leaf 22)) [] == Just 55
quickCheck $ counterexample "Sub" $
evalMaybeExpr (Sub (Leaf 33) (Leaf 22)) [] == Just 11
quickCheck $ counterexample "Mul" $
evalMaybeExpr (Mul (Leaf 31) (Leaf 4)) [] == Just 124
quickCheck $ counterexample "Uminus" $
evalMaybeExpr (Uminus (Leaf 33)) [] == Just (-33)
quickCheck $ counterexample "Complex" $
evalMaybeExpr (Mul (Leaf 4)
(Sub (Add (Leaf 3) (Uminus (Leaf 33)))
(Leaf 20))) [] == Just (-200)
-- id unit tests
quickCheck $ counterexample "ok id lookup" $
evalMaybeExpr (Id "a") [("a", 42)] == Just 42
quickCheck $ counterexample "fail id lookup" $
evalMaybeExpr (Id "a") [("b", 42)] == Nothing
quickCheck $ counterexample "id lookup: a: ok, b: fail" $
evalMaybeExpr (Add (Id "a") (Id "b")) [("a", 42)] == Nothing
quickCheck $ counterexample "id lookup: a: ok, b: ok" $
evalMaybeExpr (Add (Id "a") (Id "b")) [("a", 42), ("b", 22)] == Just 64
quickCheck $ counterexample "complex id lookup" $
evalMaybeExpr (Mul (Id "a")
(Sub (Add (Id "b") (Uminus (Id "c")))
(Id "d")))
[("a", 4), ("b", 3), ("c", 33), ("d", 20)] == Just (-200)
-- property-based tests
-- id lookup
quickCheck $ counterexample "random id lookup ok" $
(\ id1 val1 -> evalMaybeExpr (Id id1) [(id1, val1)] == Just val1)
quickCheck $ counterexample "random id lookup fail" $
(\ id1 val1 -> evalMaybeExpr (Id id1) [(id1 ++ "x", val1)] == Nothing)
-- property-based tests
-- commutativity
quickCheck $ counterexample "e1 + e2 == e2 + e1" $
(\ e1 e2 ->
evalMaybeExpr (Add (Leaf e1) (Leaf e2)) [] ==
evalMaybeExpr (Add (Leaf e2) (Leaf e1)) [])
quickCheck $ counterexample "e1 * e2 == e2 * e1" $
(\ e1 e2 ->
evalMaybeExpr (Mul (Leaf e1) (Leaf e2)) [] ==
evalMaybeExpr (Mul (Leaf e2) (Leaf e1)) [])
-- associativity
quickCheck $ counterexample "(e1 + e2) + e3 == e1 + (e2 + e3)" $
(\ e1 e2 e3 ->
evalMaybeExpr (Add (Add (Leaf e1) (Leaf e2)) (Leaf e3)) [] ==
evalMaybeExpr (Add (Leaf e1) (Add (Leaf e2) (Leaf e3))) [])
quickCheck $ counterexample "(e1 * e2) * e3 == e1 * (e2 * e3)" $
(\ e1 e2 e3 ->
evalMaybeExpr (Mul (Mul (Leaf e1) (Leaf e2)) (Leaf e3)) [] ==
evalMaybeExpr (Mul (Leaf e1) (Mul (Leaf e2) (Leaf e3))) [])
-- subtraction
quickCheck $ counterexample "e1 - e2 = -1*(e2 - e1)" $
(\ e1 e2 ->
evalMaybeExpr (Sub (Leaf e1) (Leaf e2)) [] ==
evalMaybeExpr (Mul (Leaf (-1)) (Sub (Leaf e2) (Leaf e1))) [])
-- distributivity
quickCheck $ counterexample "e1 * (e2 + e3) == e1*e2 + e1*e3" $
(\ e1 e2 e3 ->
evalMaybeExpr (Mul (Leaf e1) (Add (Leaf e2) (Leaf e3))) [] ==
evalMaybeExpr (Add (Mul (Leaf e1) (Leaf e2))
(Mul (Leaf e1) (Leaf e3))) [])
quickCheck $ counterexample "e1 * (e2 - e3) == e1*e2 - e1*e3" $
(\ e1 e2 e3 ->
evalMaybeExpr (Mul (Leaf e1) (Sub (Leaf e2) (Leaf e3))) [] ==
evalMaybeExpr (Sub (Mul (Leaf e1) (Leaf e2))
(Mul (Leaf e1) (Leaf e3))) [])
PostfixExpr.hs
This is a separate skeleton file for implementing a single function postfixExpr.
module PostfixExpr ( postfixExpr, testPostfixExpr, PostfixExpr(..) ) where
import Test.QuickCheck
-- a PostFixExpr is an expression tree over integers
data PostfixExpr =
Leaf Int |
Add PostfixExpr PostfixExpr |
Sub PostfixExpr PostfixExpr |
Mul PostfixExpr PostfixExpr |
Uminus PostfixExpr
deriving (Eq, Show)
-- Given a string postfix containing a postfix expression involving
-- integers, the usual binary arithmetic operators "+", "-", "*" as
-- well as "uminus", return the corresponding PostfixExpr. You may
-- disregard errors.
--
-- Hints:
--
-- + Use the Haskell function (words postfix) to split the
-- postfix string into String tokens.
--
-- + Iterate through the tokens using a [PostfixExpr] stack to track
-- the currently unprocessed PostfixExpr's.
--
-- + At each step of the iteration, look at the first
-- unprocessed token:
--
-- + If it is a string representing an operator, then replace
-- its operands from the head of the stack with the
-- PostfixExpr corresponding to the operator combined with its
-- operands from the stack.
--
-- + If the current unprocessed token is not an operator, assume
-- it is an Int and use (read token) to build it into a
-- Leaf.
--
-- + Use pattern matching to match different types of tokens and to
-- extract PostfixExpr operands from the head of the stack.
--
-- + Use a local auxiliary function to perform each step of the
-- iteration.
--
-- + You can use a recursive implementation of the top-level
-- function. But what is recommended is to set up your auxiliary
-- function so that you can use it to foldl the token list into
-- an accumulator representing the stack of unprocessed
-- PostfixExpr's.
--
-- + When there are no unprocessed tokens, the stack should contain
-- a single PostfixExpr containing the value to be returned.
postfixExpr :: String -> PostfixExpr
postfixExpr _ = error "TODO"
testPostfixExpr = do
print "******* test postfixExpr"
quickCheck $ counterexample "Leaf" $ postfixExpr "42" == (Leaf 42)
quickCheck $ counterexample "Add" $
postfixExpr "33 22 +" == (Add (Leaf 33) (Leaf 22))
quickCheck $ counterexample "Sub" $
postfixExpr "33 22 -" == (Sub (Leaf 33) (Leaf 22))
quickCheck $ counterexample "Mul" $
postfixExpr "31 4 *" == (Mul (Leaf 31) (Leaf 4))
quickCheck $ counterexample "Uminus" $
postfixExpr "33 uminus" == (Uminus (Leaf 33))
quickCheck $ counterexample "Complex" $
postfixExpr "4 3 33 uminus + 20 - *" ==
(Mul
(Leaf 4)
(Sub (Add (Leaf 3) (Uminus (Leaf 33))) (Leaf 20)))
TestUtils.hs
A file containing utilities used for testing. You should not need to modify this file.
module TestUtils (onlyTests, runTests, SuiteStatus(..)) where
type SuiteFn = IO ()
data SuiteStatus =
Run SuiteFn |
Skip SuiteFn |
Only SuiteFn
onlyTests [] = []
onlyTests ((Only t):tests) = t : onlyTests tests
onlyTests (_:tests) = onlyTests tests
runTests [] = []
runTests ((Run t):tests) = t : runTests tests
runTests (_:tests) = runTests tests
When writing recursive functions, use the structure of the data to guide your code. Typically your code will contain one equation for each variant of the data.
Hints for each function are available in the provided skeleton files.
You should not need to use Haskell library functions other than those mentioned explicitly in this project.
|
7e3a3be3a7edf218a8b36fa7be05904d
|
{
"intermediate": 0.39602676033973694,
"beginner": 0.40329134464263916,
"expert": 0.20068193972110748
}
|
44,459
|
module Main (main) where
import TestUtils
import EvalIntExpr (testEvalIntExpr)
import EvalIdExpr (testEvalIdExpr)
import EvalMaybeExpr (testEvalMaybeExpr)
import PostfixExpr (testPostfixExpr)
import Test.QuickCheck
---------------------------- toSingletonLists ---------------------------
-- #1: 5-points
-- Use the map function to transform a list of elements e into
-- a list of singleton lists [e]. *Must use map*.
-- Hint: use map with a section.
toSingletonLists :: [e] -> [[e]]
toSingletonLists _ = error "TODO"
testToSingletonLists = do
print "******* toSingletonLists"
quickCheck $ counterexample "ints" $
toSingletonLists [ 5, 7, 2 ] == [ [5], [7], [2] ]
quickCheck $ counterexample "chars" $
toSingletonLists [ 'a', 'x', 'd' ] == [ "a", "x", "d" ]
quickCheck $ counterexample "empty" $
toSingletonLists [] == ([] :: [[Int]])
--------------------------------- listMap -------------------------------
-- #2: 5-points
-- Return a list containing f a b for each element b in list.
-- Hint: use the map function or a list comprehension
listMap :: (a -> b -> c) -> a -> [b] -> [c]
listMap _ _ _ = error "TODO"
testListMap = do
print "******* listMap"
quickCheck $ counterexample "add" $ listMap (+) 5 [1, 2, 3] == [6, 7, 8]
quickCheck $ counterexample "sub" $ listMap (-) 5 [1, 2, 3] == [4, 3, 2]
quickCheck $ counterexample "mul" $ listMap (*) 5 [1, 2, 3] == [5, 10, 15]
quickCheck $ counterexample "empty" $ listMap (-) 5 [] == []
---------------------------------- member -------------------------------
-- #3: 10-points
-- Use foldl to implement member e list which returns True iff
-- e is a member of list. *Must use foldl*, cannot use elem
-- Hint: define folding function using a lambda or local let/where definition;
-- also see definition of member in slides.
member :: Eq e => e -> [e] -> Bool
member _ _ = error "TODO"
testMember = do
print "******* member"
quickCheck $ counterexample "ints first" $ member 5 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints last" $ member 2 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints mid" $ member 7 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints fail" $ member 4 [ 5, 7, 2 ] == False
quickCheck $ counterexample "empty" $ member 4 [] == False
------------------------------- selectNApart ----------------------------
-- #4: 10-points
-- Given an Int n and a list of elements e, return a list
-- containing the elements of the list at index 0, n, 2n, 3n, 4n, ...
-- Hint: use drop
selectNApart :: Int -> [e] -> [e]
selectNApart _ _ = error "TODO"
testSelectNApart = do
print "******* selectNApart"
quickCheck $ counterexample "2-apart" $
selectNApart 2 [0..10] == [0, 2, 4, 6, 8, 10]
quickCheck $ counterexample "2-apart chars" $
selectNApart 2 ['a'..'z'] == "acegikmoqsuwy"
quickCheck $ counterexample "3-apart" $
selectNApart 3 [0..20] == [0, 3, 6, 9, 12, 15, 18]
quickCheck $ counterexample "5-apart" $
selectNApart 5 [0..21] == [0, 5, 10, 15, 20]
quickCheck $ counterexample "empty" $ selectNApart 5 ([]::[Int]) == []
------------------------ Functions in Separate Files --------------------
-- #5: 15-points
-- implement the specified function in EvalIntExpr.hs
-- #6: 15-points
-- implement the specified function in EvalIdExpr.hs
-- #7: 20-points
-- implement the specified function in EvalMaybeExpr.hs
-- #8: 20-points
-- implement the specified function in PostfixExpr.hs
--------------------------------- Tests ---------------------------------
-- Can mark test suites with following test statuses:
-- Only: run only these tests and other tests marked Only.
-- Run: run these tests when no tests are marked Only.
-- Skip: skip these tests.
allTests = [
(Skip testToSingletonLists),
(Skip testListMap),
(Skip testMember),
(Skip testSelectNApart),
(Skip testEvalIntExpr),
(Skip testEvalIdExpr),
(Skip testEvalMaybeExpr),
(Skip testPostfixExpr)
]
main = do
mapM_ id tests
where
only = onlyTests allTests
tests = if (length only > 0) then only else runTests allTests
|
ab67ed884390b1727b61c785e4295c44
|
{
"intermediate": 0.3388419449329376,
"beginner": 0.43419554829597473,
"expert": 0.22696255147457123
}
|
44,460
|
module Main (main) where
import TestUtils
import EvalIntExpr (testEvalIntExpr)
import EvalIdExpr (testEvalIdExpr)
import EvalMaybeExpr (testEvalMaybeExpr)
import PostfixExpr (testPostfixExpr)
import Test.QuickCheck
---------------------------- toSingletonLists ---------------------------
-- #1: 5-points
-- Use the map function to transform a list of elements e into
-- a list of singleton lists [e]. *Must use map*.
-- Hint: use map with a section.
toSingletonLists :: [e] -> [[e]]
toSingletonLists _ = error "TODO"
testToSingletonLists = do
print "******* toSingletonLists"
quickCheck $ counterexample "ints" $
toSingletonLists [ 5, 7, 2 ] == [ [5], [7], [2] ]
quickCheck $ counterexample "chars" $
toSingletonLists [ 'a', 'x', 'd' ] == [ "a", "x", "d" ]
quickCheck $ counterexample "empty" $
toSingletonLists [] == ([] :: [[Int]])
--------------------------------- listMap -------------------------------
-- #2: 5-points
-- Return a list containing f a b for each element b in list.
-- Hint: use the map function or a list comprehension
listMap :: (a -> b -> c) -> a -> [b] -> [c]
listMap _ _ _ = error "TODO"
testListMap = do
print "******* listMap"
quickCheck $ counterexample "add" $ listMap (+) 5 [1, 2, 3] == [6, 7, 8]
quickCheck $ counterexample "sub" $ listMap (-) 5 [1, 2, 3] == [4, 3, 2]
quickCheck $ counterexample "mul" $ listMap (*) 5 [1, 2, 3] == [5, 10, 15]
quickCheck $ counterexample "empty" $ listMap (-) 5 [] == []
---------------------------------- member -------------------------------
-- #3: 10-points
-- Use foldl to implement member e list which returns True iff
-- e is a member of list. *Must use foldl*, cannot use elem
-- Hint: define folding function using a lambda or local let/where definition;
-- also see definition of member in slides.
member :: Eq e => e -> [e] -> Bool
member _ _ = error "TODO"
testMember = do
print "******* member"
quickCheck $ counterexample "ints first" $ member 5 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints last" $ member 2 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints mid" $ member 7 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints fail" $ member 4 [ 5, 7, 2 ] == False
quickCheck $ counterexample "empty" $ member 4 [] == False
------------------------------- selectNApart ----------------------------
-- #4: 10-points
-- Given an Int n and a list of elements e, return a list
-- containing the elements of the list at index 0, n, 2n, 3n, 4n, ...
-- Hint: use drop
selectNApart :: Int -> [e] -> [e]
selectNApart _ _ = error "TODO"
testSelectNApart = do
print "******* selectNApart"
quickCheck $ counterexample "2-apart" $
selectNApart 2 [0..10] == [0, 2, 4, 6, 8, 10]
quickCheck $ counterexample "2-apart chars" $
selectNApart 2 ['a'..'z'] == "acegikmoqsuwy"
quickCheck $ counterexample "3-apart" $
selectNApart 3 [0..20] == [0, 3, 6, 9, 12, 15, 18]
quickCheck $ counterexample "5-apart" $
selectNApart 5 [0..21] == [0, 5, 10, 15, 20]
quickCheck $ counterexample "empty" $ selectNApart 5 ([]::[Int]) == []
------------------------ Functions in Separate Files --------------------
-- #5: 15-points
-- implement the specified function in EvalIntExpr.hs
-- #6: 15-points
-- implement the specified function in EvalIdExpr.hs
-- #7: 20-points
-- implement the specified function in EvalMaybeExpr.hs
-- #8: 20-points
-- implement the specified function in PostfixExpr.hs
--------------------------------- Tests ---------------------------------
-- Can mark test suites with following test statuses:
-- Only: run only these tests and other tests marked Only.
-- Run: run these tests when no tests are marked Only.
-- Skip: skip these tests.
allTests = [
(Skip testToSingletonLists),
(Skip testListMap),
(Skip testMember),
(Skip testSelectNApart),
(Skip testEvalIntExpr),
(Skip testEvalIdExpr),
(Skip testEvalMaybeExpr),
(Skip testPostfixExpr)
]
main = do
mapM_ id tests
where
only = onlyTests allTests
tests = if (length only > 0) then only else runTests allTests
|
8ef14aad6ceeabd003339707af509b8c
|
{
"intermediate": 0.3388419449329376,
"beginner": 0.43419554829597473,
"expert": 0.22696255147457123
}
|
44,461
|
i have trained a model that gives me signal for trading crypto
my model is saved as "crypto_model.joblib"
how can write a python code for using this signals and trade crypto on a demo account ?
|
0048c0c1380ec0da2d021447dbd7e3e8
|
{
"intermediate": 0.42780572175979614,
"beginner": 0.09557342529296875,
"expert": 0.4766208827495575
}
|
44,462
|
Use the Glasgow Haskell Compiler ghc to implement all the functions specified in Main.hs and in the skeleton files referenced by Main.hs.
When a function requirement specifies a restriction on how that function should be implemented, your implementation must meet that restriction.
Main.hs
A skeleton file which contains specifications for the some of the functions you are required to write. For each function it contains a dummy implementation with a "TODO" error. It also contains QuickCheck tests for these functions as well as a main function which runs all of the tests for the entire project.
module Main (main) where
import TestUtils
import EvalIntExpr (testEvalIntExpr)
import EvalIdExpr (testEvalIdExpr)
import EvalMaybeExpr (testEvalMaybeExpr)
import PostfixExpr (testPostfixExpr)
import Test.QuickCheck
---------------------------- toSingletonLists ---------------------------
-- #1: 5-points
-- Use the map function to transform a list of elements e into
-- a list of singleton lists [e]. *Must use map*.
-- Hint: use map with a section.
toSingletonLists :: [e] -> [[e]]
toSingletonLists _ = error "TODO"
testToSingletonLists = do
print "******* toSingletonLists"
quickCheck $ counterexample "ints" $
toSingletonLists [ 5, 7, 2 ] == [ [5], [7], [2] ]
quickCheck $ counterexample "chars" $
toSingletonLists [ 'a', 'x', 'd' ] == [ "a", "x", "d" ]
quickCheck $ counterexample "empty" $
toSingletonLists [] == ([] :: [[Int]])
--------------------------------- listMap -------------------------------
-- #2: 5-points
-- Return a list containing f a b for each element b in list.
-- Hint: use the map function or a list comprehension
listMap :: (a -> b -> c) -> a -> [b] -> [c]
listMap _ _ _ = error "TODO"
testListMap = do
print "******* listMap"
quickCheck $ counterexample "add" $ listMap (+) 5 [1, 2, 3] == [6, 7, 8]
quickCheck $ counterexample "sub" $ listMap (-) 5 [1, 2, 3] == [4, 3, 2]
quickCheck $ counterexample "mul" $ listMap (*) 5 [1, 2, 3] == [5, 10, 15]
quickCheck $ counterexample "empty" $ listMap (-) 5 [] == []
---------------------------------- member -------------------------------
-- #3: 10-points
-- Use foldl to implement member e list which returns True iff
-- e is a member of list. *Must use foldl*, cannot use elem
-- Hint: define folding function using a lambda or local let/where definition;
-- also see definition of member in slides.
member :: Eq e => e -> [e] -> Bool
member _ _ = error "TODO"
testMember = do
print "******* member"
quickCheck $ counterexample "ints first" $ member 5 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints last" $ member 2 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints mid" $ member 7 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints fail" $ member 4 [ 5, 7, 2 ] == False
quickCheck $ counterexample "empty" $ member 4 [] == False
------------------------------- selectNApart ----------------------------
-- #4: 10-points
-- Given an Int n and a list of elements e, return a list
-- containing the elements of the list at index 0, n, 2n, 3n, 4n, ...
-- Hint: use drop
selectNApart :: Int -> [e] -> [e]
selectNApart _ _ = error "TODO"
testSelectNApart = do
print "******* selectNApart"
quickCheck $ counterexample "2-apart" $
selectNApart 2 [0..10] == [0, 2, 4, 6, 8, 10]
quickCheck $ counterexample "2-apart chars" $
selectNApart 2 ['a'..'z'] == "acegikmoqsuwy"
quickCheck $ counterexample "3-apart" $
selectNApart 3 [0..20] == [0, 3, 6, 9, 12, 15, 18]
quickCheck $ counterexample "5-apart" $
selectNApart 5 [0..21] == [0, 5, 10, 15, 20]
quickCheck $ counterexample "empty" $ selectNApart 5 ([]::[Int]) == []
------------------------ Functions in Separate Files --------------------
-- #5: 15-points
-- implement the specified function in EvalIntExpr.hs
-- #6: 15-points
-- implement the specified function in EvalIdExpr.hs
-- #7: 20-points
-- implement the specified function in EvalMaybeExpr.hs
-- #8: 20-points
-- implement the specified function in PostfixExpr.hs
--------------------------------- Tests ---------------------------------
-- Can mark test suites with following test statuses:
-- Only: run only these tests and other tests marked Only.
-- Run: run these tests when no tests are marked Only.
-- Skip: skip these tests.
allTests = [
(Skip testToSingletonLists),
(Skip testListMap),
(Skip testMember),
(Skip testSelectNApart),
(Skip testEvalIntExpr),
(Skip testEvalIdExpr),
(Skip testEvalMaybeExpr),
(Skip testPostfixExpr)
]
main = do
mapM_ id tests
where
only = onlyTests allTests
tests = if (length only > 0) then only else runTests allTests
EvalIntExpr.hs
This is a separate skeleton file for implementing a single function evalIntExpr.
module EvalIntExpr ( evalIntExpr, testEvalIntExpr, IntExpr(..) ) where
import Test.QuickCheck
-- an IntExpr is an expression-tree over integers
data IntExpr =
Leaf Int |
Add IntExpr IntExpr |
Sub IntExpr IntExpr |
Mul IntExpr IntExpr |
Uminus IntExpr
deriving (Eq, Show)
-- evalIntExpr returns the Int result of evaluating the IntExpr
-- expression-tree given by its argument.
evalIntExpr :: IntExpr -> Int
evalIntExpr _ = error "TODO"
testEvalIntExpr = do
print "******* test evalIntExpr"
quickCheck $ counterexample "Leaf" $ evalIntExpr (Leaf 42) == 42
quickCheck $ counterexample "Add" $
evalIntExpr (Add (Leaf 33) (Leaf 22)) == 55
quickCheck $ counterexample "Sub" $
evalIntExpr (Sub (Leaf 33) (Leaf 22)) == 11
quickCheck $ counterexample "Mul" $
evalIntExpr (Mul (Leaf 31) (Leaf 4)) == 124
quickCheck $ counterexample "Uminus" $
evalIntExpr (Uminus (Leaf 33)) == (-33)
quickCheck $ counterexample "Complex" $
evalIntExpr (Mul (Leaf 4)
(Sub (Add (Leaf 3) (Uminus (Leaf 33)))
(Leaf 20))) == (-200)
-- property-based tests
-- commutativity
quickCheck $ counterexample "e1 + e2 == e2 + e1" $
(\ e1 e2 ->
evalIntExpr (Add (Leaf e1) (Leaf e2)) ==
evalIntExpr (Add (Leaf e2) (Leaf e1)))
quickCheck $ counterexample "e1 * e2 == e2 * e1" $
(\ e1 e2 ->
evalIntExpr (Mul (Leaf e1) (Leaf e2)) ==
evalIntExpr (Mul (Leaf e2) (Leaf e1)))
-- associativity
quickCheck $ counterexample "(e1 + e2) + e3 == e1 + (e2 + e3)" $
(\ e1 e2 e3 ->
evalIntExpr (Add (Add (Leaf e1) (Leaf e2)) (Leaf e3)) ==
evalIntExpr (Add (Leaf e1) (Add (Leaf e2) (Leaf e3))))
quickCheck $ counterexample "(e1 * e2) * e3 == e1 * (e2 * e3)" $
(\ e1 e2 e3 ->
evalIntExpr (Mul (Mul (Leaf e1) (Leaf e2)) (Leaf e3)) ==
evalIntExpr (Mul (Leaf e1) (Mul (Leaf e2) (Leaf e3))))
-- subtraction
quickCheck $ counterexample "e1 - e2 = -1*(e2 - e1)" $
(\ e1 e2 ->
evalIntExpr (Sub (Leaf e1) (Leaf e2)) ==
evalIntExpr (Mul (Leaf (-1)) (Sub (Leaf e2) (Leaf e1))))
-- distributivity
quickCheck $ counterexample "e1 * (e2 + e3) == e1*e2 + e1*e3" $
(\ e1 e2 e3 ->
evalIntExpr (Mul (Leaf e1) (Add (Leaf e2) (Leaf e3))) ==
evalIntExpr (Add (Mul (Leaf e1) (Leaf e2))
(Mul (Leaf e1) (Leaf e3))))
quickCheck $ counterexample "e1 * (e2 - e3) == e1*e2 - e1*e3" $
(\ e1 e2 e3 ->
evalIntExpr (Mul (Leaf e1) (Sub (Leaf e2) (Leaf e3))) ==
evalIntExpr (Sub (Mul (Leaf e1) (Leaf e2))
(Mul (Leaf e1) (Leaf e3))))
EvalIdExpr.hs
This is a separate skeleton file for implementing a single function evalIdExpr.
module EvalIdExpr ( evalIdExpr, testEvalIdExpr ) where
import Test.QuickCheck
import Data.List (lookup)
-- an IdExpr is an expression-tree over integers and string identifiers
data IdExpr =
Id String |
Leaf Int |
Add IdExpr IdExpr |
Sub IdExpr IdExpr |
Mul IdExpr IdExpr |
Uminus IdExpr
deriving (Eq, Show)
-- Assoc is a list of pairs mapping identifier strings to their values v.
type Assoc v = [ (String, v) ]
-- evalIdExpr returns evaluation of the IdExpr expression-tree given
-- by its first argument, looking up the values of id's in the Assoc
-- argument. If an id is not found in the Assoc argument, then its
-- value should default to 0.
-- Hint: use Data.List.lookup imported above.
evalIdExpr :: IdExpr -> Assoc Int -> Int
evalIdExpr _ = error "TODO"
testEvalIdExpr = do
print "*** test evalIdExpr"
-- unit tests
quickCheck $ counterexample "Leaf" $ evalIdExpr (Leaf 42) [] == 42
quickCheck $ counterexample "Add" $
evalIdExpr (Add (Leaf 33) (Leaf 22)) [] == 55
quickCheck $ counterexample "Sub" $
evalIdExpr (Sub (Leaf 33) (Leaf 22)) [] == 11
quickCheck $ counterexample "Mul" $
evalIdExpr (Mul (Leaf 31) (Leaf 4)) [] == 124
quickCheck $ counterexample "Uminus" $
evalIdExpr (Uminus (Leaf 33)) [] == (-33)
quickCheck $ counterexample "Complex" $
evalIdExpr (Mul (Leaf 4)
(Sub (Add (Leaf 3) (Uminus (Leaf 33)))
(Leaf 20))) [] == (-200)
-- id unit tests
quickCheck $ counterexample "ok id lookup" $
evalIdExpr (Id "a") [("a", 42)] == 42
quickCheck $ counterexample "fail id lookup" $
evalIdExpr (Id "a") [("b", 42)] == 0
quickCheck $ counterexample "id lookup: a: ok, b: fail" $
evalIdExpr (Add (Id "a") (Id "b")) [("a", 42)] == 42
quickCheck $ counterexample "id lookup: a: ok, b: ok" $
evalIdExpr (Add (Id "a") (Id "b")) [("a", 42), ("b", 22)] == 64
quickCheck $ counterexample "complex id lookup" $
evalIdExpr (Mul (Id "a")
(Sub (Add (Id "b") (Uminus (Id "c")))
(Id "d")))
[("a", 4), ("b", 3), ("c", 33), ("d", 20)] == (-200)
-- property-based tests
-- id lookup
quickCheck $ counterexample "random id lookup ok" $
(\ id1 val1 -> evalIdExpr (Id id1) [(id1, val1)] == val1)
quickCheck $ counterexample "random id lookup fail" $
(\ id1 val1 -> evalIdExpr (Id id1) [(id1 ++ "x", val1)] == 0)
-- property-based tests
-- commutativity
quickCheck $ counterexample "e1 + e2 == e2 + e1" $
(\ e1 e2 ->
evalIdExpr (Add (Leaf e1) (Leaf e2)) [] ==
evalIdExpr (Add (Leaf e2) (Leaf e1)) [])
quickCheck $ counterexample "e1 * e2 == e2 * e1" $
(\ e1 e2 ->
evalIdExpr (Mul (Leaf e1) (Leaf e2)) [] ==
evalIdExpr (Mul (Leaf e2) (Leaf e1)) [])
-- associativity
quickCheck $ counterexample "(e1 + e2) + e3 == e1 + (e2 + e3)" $
(\ e1 e2 e3 ->
evalIdExpr (Add (Add (Leaf e1) (Leaf e2)) (Leaf e3)) [] ==
evalIdExpr (Add (Leaf e1) (Add (Leaf e2) (Leaf e3))) [])
quickCheck $ counterexample "(e1 * e2) * e3 == e1 * (e2 * e3)" $
(\ e1 e2 e3 ->
evalIdExpr (Mul (Mul (Leaf e1) (Leaf e2)) (Leaf e3)) [] ==
evalIdExpr (Mul (Leaf e1) (Mul (Leaf e2) (Leaf e3))) [])
-- subtraction
quickCheck $ counterexample "e1 - e2 = -1*(e2 - e1)" $
(\ e1 e2 ->
evalIdExpr (Sub (Leaf e1) (Leaf e2)) [] ==
evalIdExpr (Mul (Leaf (-1)) (Sub (Leaf e2) (Leaf e1))) [])
-- distributivity
quickCheck $ counterexample "e1 * (e2 + e3) == e1*e2 + e1*e3" $
(\ e1 e2 e3 ->
evalIdExpr (Mul (Leaf e1) (Add (Leaf e2) (Leaf e3))) [] ==
evalIdExpr (Add (Mul (Leaf e1) (Leaf e2))
(Mul (Leaf e1) (Leaf e3))) [])
quickCheck $ counterexample "e1 * (e2 - e3) == e1*e2 - e1*e3" $
(\ e1 e2 e3 ->
evalIdExpr (Mul (Leaf e1) (Sub (Leaf e2) (Leaf e3))) [] ==
evalIdExpr (Sub (Mul (Leaf e1) (Leaf e2))
(Mul (Leaf e1) (Leaf e3))) [])
EvalMaybeExpr.hs
This is a separate skeleton file for implementing a single function evalMaybeExpr.
module EvalMaybeExpr ( evalMaybeExpr, testEvalMaybeExpr ) where
import Test.QuickCheck
import Data.List (lookup)
data MaybeExpr =
Id String |
Leaf Int |
Add MaybeExpr MaybeExpr |
Sub MaybeExpr MaybeExpr |
Mul MaybeExpr MaybeExpr |
Uminus MaybeExpr
deriving (Eq, Show)
type Assoc a = [ (String, a) ]
-- return a Maybe wrapping the results of evaluating expr, looking up
-- id's in assoc. If an id is not found in assoc, then the function
-- should return Nothing. Hint: use Data.List.assoc imported above
-- and do notation.
evalMaybeExpr :: MaybeExpr -> Assoc Int -> Maybe Int
evalMaybeExpr _ _ = error "TODO"
testEvalMaybeExpr = do
print "*** test evalMaybeExpr"
-- unit tests
quickCheck $ counterexample "Leaf" $ evalMaybeExpr (Leaf 42) [] == Just 42
quickCheck $ counterexample "Add" $
evalMaybeExpr (Add (Leaf 33) (Leaf 22)) [] == Just 55
quickCheck $ counterexample "Sub" $
evalMaybeExpr (Sub (Leaf 33) (Leaf 22)) [] == Just 11
quickCheck $ counterexample "Mul" $
evalMaybeExpr (Mul (Leaf 31) (Leaf 4)) [] == Just 124
quickCheck $ counterexample "Uminus" $
evalMaybeExpr (Uminus (Leaf 33)) [] == Just (-33)
quickCheck $ counterexample "Complex" $
evalMaybeExpr (Mul (Leaf 4)
(Sub (Add (Leaf 3) (Uminus (Leaf 33)))
(Leaf 20))) [] == Just (-200)
-- id unit tests
quickCheck $ counterexample "ok id lookup" $
evalMaybeExpr (Id "a") [("a", 42)] == Just 42
quickCheck $ counterexample "fail id lookup" $
evalMaybeExpr (Id "a") [("b", 42)] == Nothing
quickCheck $ counterexample "id lookup: a: ok, b: fail" $
evalMaybeExpr (Add (Id "a") (Id "b")) [("a", 42)] == Nothing
quickCheck $ counterexample "id lookup: a: ok, b: ok" $
evalMaybeExpr (Add (Id "a") (Id "b")) [("a", 42), ("b", 22)] == Just 64
quickCheck $ counterexample "complex id lookup" $
evalMaybeExpr (Mul (Id "a")
(Sub (Add (Id "b") (Uminus (Id "c")))
(Id "d")))
[("a", 4), ("b", 3), ("c", 33), ("d", 20)] == Just (-200)
-- property-based tests
-- id lookup
quickCheck $ counterexample "random id lookup ok" $
(\ id1 val1 -> evalMaybeExpr (Id id1) [(id1, val1)] == Just val1)
quickCheck $ counterexample "random id lookup fail" $
(\ id1 val1 -> evalMaybeExpr (Id id1) [(id1 ++ "x", val1)] == Nothing)
-- property-based tests
-- commutativity
quickCheck $ counterexample "e1 + e2 == e2 + e1" $
(\ e1 e2 ->
evalMaybeExpr (Add (Leaf e1) (Leaf e2)) [] ==
evalMaybeExpr (Add (Leaf e2) (Leaf e1)) [])
quickCheck $ counterexample "e1 * e2 == e2 * e1" $
(\ e1 e2 ->
evalMaybeExpr (Mul (Leaf e1) (Leaf e2)) [] ==
evalMaybeExpr (Mul (Leaf e2) (Leaf e1)) [])
-- associativity
quickCheck $ counterexample "(e1 + e2) + e3 == e1 + (e2 + e3)" $
(\ e1 e2 e3 ->
evalMaybeExpr (Add (Add (Leaf e1) (Leaf e2)) (Leaf e3)) [] ==
evalMaybeExpr (Add (Leaf e1) (Add (Leaf e2) (Leaf e3))) [])
quickCheck $ counterexample "(e1 * e2) * e3 == e1 * (e2 * e3)" $
(\ e1 e2 e3 ->
evalMaybeExpr (Mul (Mul (Leaf e1) (Leaf e2)) (Leaf e3)) [] ==
evalMaybeExpr (Mul (Leaf e1) (Mul (Leaf e2) (Leaf e3))) [])
-- subtraction
quickCheck $ counterexample "e1 - e2 = -1*(e2 - e1)" $
(\ e1 e2 ->
evalMaybeExpr (Sub (Leaf e1) (Leaf e2)) [] ==
evalMaybeExpr (Mul (Leaf (-1)) (Sub (Leaf e2) (Leaf e1))) [])
-- distributivity
quickCheck $ counterexample "e1 * (e2 + e3) == e1*e2 + e1*e3" $
(\ e1 e2 e3 ->
evalMaybeExpr (Mul (Leaf e1) (Add (Leaf e2) (Leaf e3))) [] ==
evalMaybeExpr (Add (Mul (Leaf e1) (Leaf e2))
(Mul (Leaf e1) (Leaf e3))) [])
quickCheck $ counterexample "e1 * (e2 - e3) == e1*e2 - e1*e3" $
(\ e1 e2 e3 ->
evalMaybeExpr (Mul (Leaf e1) (Sub (Leaf e2) (Leaf e3))) [] ==
evalMaybeExpr (Sub (Mul (Leaf e1) (Leaf e2))
(Mul (Leaf e1) (Leaf e3))) [])
PostfixExpr.hs
This is a separate skeleton file for implementing a single function postfixExpr.
module PostfixExpr ( postfixExpr, testPostfixExpr, PostfixExpr(..) ) where
import Test.QuickCheck
-- a PostFixExpr is an expression tree over integers
data PostfixExpr =
Leaf Int |
Add PostfixExpr PostfixExpr |
Sub PostfixExpr PostfixExpr |
Mul PostfixExpr PostfixExpr |
Uminus PostfixExpr
deriving (Eq, Show)
-- Given a string postfix containing a postfix expression involving
-- integers, the usual binary arithmetic operators "+", "-", "*" as
-- well as "uminus", return the corresponding PostfixExpr. You may
-- disregard errors.
--
-- Hints:
--
-- + Use the Haskell function (words postfix) to split the
-- postfix string into String tokens.
--
-- + Iterate through the tokens using a [PostfixExpr] stack to track
-- the currently unprocessed PostfixExpr's.
--
-- + At each step of the iteration, look at the first
-- unprocessed token:
--
-- + If it is a string representing an operator, then replace
-- its operands from the head of the stack with the
-- PostfixExpr corresponding to the operator combined with its
-- operands from the stack.
--
-- + If the current unprocessed token is not an operator, assume
-- it is an Int and use (read token) to build it into a
-- Leaf.
--
-- + Use pattern matching to match different types of tokens and to
-- extract PostfixExpr operands from the head of the stack.
--
-- + Use a local auxiliary function to perform each step of the
-- iteration.
--
-- + You can use a recursive implementation of the top-level
-- function. But what is recommended is to set up your auxiliary
-- function so that you can use it to foldl the token list into
-- an accumulator representing the stack of unprocessed
-- PostfixExpr's.
--
-- + When there are no unprocessed tokens, the stack should contain
-- a single PostfixExpr containing the value to be returned.
postfixExpr :: String -> PostfixExpr
postfixExpr _ = error "TODO"
testPostfixExpr = do
print "******* test postfixExpr"
quickCheck $ counterexample "Leaf" $ postfixExpr "42" == (Leaf 42)
quickCheck $ counterexample "Add" $
postfixExpr "33 22 +" == (Add (Leaf 33) (Leaf 22))
quickCheck $ counterexample "Sub" $
postfixExpr "33 22 -" == (Sub (Leaf 33) (Leaf 22))
quickCheck $ counterexample "Mul" $
postfixExpr "31 4 *" == (Mul (Leaf 31) (Leaf 4))
quickCheck $ counterexample "Uminus" $
postfixExpr "33 uminus" == (Uminus (Leaf 33))
quickCheck $ counterexample "Complex" $
postfixExpr "4 3 33 uminus + 20 - *" ==
(Mul
(Leaf 4)
(Sub (Add (Leaf 3) (Uminus (Leaf 33))) (Leaf 20)))
TestUtils.hs
A file containing utilities used for testing. You should not need to modify this file.
module TestUtils (onlyTests, runTests, SuiteStatus(..)) where
type SuiteFn = IO ()
data SuiteStatus =
Run SuiteFn |
Skip SuiteFn |
Only SuiteFn
onlyTests [] = []
onlyTests ((Only t):tests) = t : onlyTests tests
onlyTests (_:tests) = onlyTests tests
runTests [] = []
runTests ((Run t):tests) = t : runTests tests
runTests (_:tests) = runTests tests
When writing recursive functions, use the structure of the data to guide your code. Typically your code will contain one equation for each variant of the data.
Hints for each function are available in the provided skeleton files.
You should not need to use Haskell library functions other than those mentioned explicitly in this project.
|
f4baf9d3fd0f5ce3e1b55298b744c1db
|
{
"intermediate": 0.39602676033973694,
"beginner": 0.40329134464263916,
"expert": 0.20068193972110748
}
|
44,463
|
i have trained and saved a decision ensemble tree using xgboost
how can i see the nodes of traned trees?
|
d8b3eaffcbe0db2fa14a5e47263a706f
|
{
"intermediate": 0.21335744857788086,
"beginner": 0.061004091054201126,
"expert": 0.7256384491920471
}
|
44,464
|
I have the following makefile "objects = main.o
etch : $(objects)
gcc -o build/etch $(objects)
main.o : main.c
gcc -c main.c
.PHONY : clean
clean :
rm build/etch"
When I try to run make I get the error that on line 4 there is a missing separator. What am I doing wrong?
|
0ca98fc65a29cdd647331199d0e1a94a
|
{
"intermediate": 0.492730051279068,
"beginner": 0.28603389859199524,
"expert": 0.22123605012893677
}
|
44,465
|
Give a heap of integers based on the usual ≤ ordering which includes the values of 3, 13, 7, 8, 7, 9, 7 and 12
|
d9024eb0619499060fb98d994ac1eafb
|
{
"intermediate": 0.445934534072876,
"beginner": 0.32148978114128113,
"expert": 0.2325756996870041
}
|
44,466
|
Draw a heap of integers based on the usual ≤ ordering which includes the values of 3, 13, 7, 8, 7, 9 ,7 and 12. Be brief.
|
71a730bcbdcd44cb330acd5749fdb23f
|
{
"intermediate": 0.4648098945617676,
"beginner": 0.3068866729736328,
"expert": 0.2283034771680832
}
|
44,467
|
Draw a heap of integers based on the usual ≤ ordering which includes the values of 3, 13, 7, 8, 7, 9 ,7 and 12
|
78942dee8bc6cec67500deb9b20b9747
|
{
"intermediate": 0.48737525939941406,
"beginner": 0.3095172047615051,
"expert": 0.203107550740242
}
|
44,468
|
Draw a heap of integers based on the usual ≤ ordering which includes the values of 3, 13, 7, 8, 7, 9 ,7 and 12. Be brief.
|
9be00684880a738bdc80c0c25880e9d1
|
{
"intermediate": 0.4648098945617676,
"beginner": 0.3068866729736328,
"expert": 0.2283034771680832
}
|
44,469
|
Draw a heap of integers based on the usual ≤ ordering which includes the values of 3, 13, 7, 8, 7, 9 ,7 and 12. What are the steps to building it?
|
a853201f4a109c8a2dc4dd1330aa00bc
|
{
"intermediate": 0.49600881338119507,
"beginner": 0.22494642436504364,
"expert": 0.2790446877479553
}
|
44,470
|
Hi can I configure a copilot virtual agent bot to access sharepoint online sites and its contents?
|
6afb929e0c518a052f6c725c57adb9b5
|
{
"intermediate": 0.3198210597038269,
"beginner": 0.18793520331382751,
"expert": 0.49224376678466797
}
|
44,471
|
get equation of line excel
|
49494eb47c3699c4e57db94b7d1ca247
|
{
"intermediate": 0.34720900654792786,
"beginner": 0.2759135961532593,
"expert": 0.37687742710113525
}
|
44,472
|
Draw a heap of integers based on the usual ≤ ordering which includes the values of 3, 13, 7, 8, 7, 9 ,7 and 12. Be brief.
|
2a297d31613b22a71c4ac0d2b0a28b16
|
{
"intermediate": 0.4648098945617676,
"beginner": 0.3068866729736328,
"expert": 0.2283034771680832
}
|
44,473
|
module Main (main) where
import TestUtils
import EvalIntExpr (testEvalIntExpr)
import EvalIdExpr (testEvalIdExpr)
import EvalMaybeExpr (testEvalMaybeExpr)
import PostfixExpr (testPostfixExpr)
import Test.QuickCheck
toSingletonLists :: [e] -> [[e]]
toSingletonLists _ = error "TODO"
testToSingletonLists = do
print "******* toSingletonLists"
quickCheck $ counterexample "ints" $
toSingletonLists [ 5, 7, 2 ] == [ [5], [7], [2] ]
quickCheck $ counterexample "chars" $
toSingletonLists [ 'a', 'x', 'd' ] == [ "a", "x", "d" ]
quickCheck $ counterexample "empty" $
toSingletonLists [] == ([] :: [[Int]])
listMap :: (a -> b -> c) -> a -> [b] -> [c]
listMap _ _ _ = error "TODO"
testListMap = do
print "******* listMap"
quickCheck $ counterexample "add" $ listMap (+) 5 [1, 2, 3] == [6, 7, 8]
quickCheck $ counterexample "sub" $ listMap (-) 5 [1, 2, 3] == [4, 3, 2]
quickCheck $ counterexample "mul" $ listMap (*) 5 [1, 2, 3] == [5, 10, 15]
quickCheck $ counterexample "empty" $ listMap (-) 5 [] == []
member :: Eq e => e -> [e] -> Bool
member _ _ = error "TODO"
testMember = do
print "******* member"
quickCheck $ counterexample "ints first" $ member 5 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints last" $ member 2 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints mid" $ member 7 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints fail" $ member 4 [ 5, 7, 2 ] == False
quickCheck $ counterexample "empty" $ member 4 [] == False
selectNApart :: Int -> [e] -> [e]
selectNApart _ _ = error "TODO"
testSelectNApart = do
print "******* selectNApart"
quickCheck $ counterexample "2-apart" $
selectNApart 2 [0..10] == [0, 2, 4, 6, 8, 10]
quickCheck $ counterexample "2-apart chars" $
selectNApart 2 ['a'..'z'] == "acegikmoqsuwy"
quickCheck $ counterexample "3-apart" $
selectNApart 3 [0..20] == [0, 3, 6, 9, 12, 15, 18]
quickCheck $ counterexample "5-apart" $
selectNApart 5 [0..21] == [0, 5, 10, 15, 20]
quickCheck $ counterexample "empty" $ selectNApart 5 ([]::[Int]) == []
------------------------ Functions in Separate Files --------------------
-- #5: 15-points
-- implement the specified function in EvalIntExpr.hs
-- #6: 15-points
-- implement the specified function in EvalIdExpr.hs
-- #7: 20-points
-- implement the specified function in EvalMaybeExpr.hs
-- #8: 20-points
-- implement the specified function in PostfixExpr.hs
allTests = [
(Skip testToSingletonLists),
(Skip testListMap),
(Skip testMember),
(Skip testSelectNApart),
(Skip testEvalIntExpr),
(Skip testEvalIdExpr),
(Skip testEvalMaybeExpr),
(Skip testPostfixExpr)
]
main = do
mapM_ id tests
where
only = onlyTests allTests
tests = if (length only > 0) then only else runTests allTests
For toSingletonLists use the map function to transform a list of elements e into a list of singleton lists [e]. *Must use map*.
Hint: use map with a section.
For listMap return a list containing f a b for each element b in list.
Hint: use the map function or a list comprehension
For member use foldl to implement member e list which returns True if e is a member of list. *Must use foldl*, cannot use elem
Hint: define folding function using a lambda or local let/where definition.
For selectNApart, Given an Int n and a list of elements e, return a list containing the elements of the list at index 0, n, 2n, 3n, 4n, and so on
Hint: use drop
For Tests, Can mark test suites with following test statuses:
Only: run only these tests and other tests marked Only.
Run: run these tests when no tests are marked Only.
Skip: skip these tests.
Ensure that all test suites are set to Run.
|
955641700669bf6f94d7b53d2ad64344
|
{
"intermediate": 0.34335896372795105,
"beginner": 0.45357275009155273,
"expert": 0.20306828618049622
}
|
44,474
|
module Main (main) where
import TestUtils
import EvalIntExpr (testEvalIntExpr)
import EvalIdExpr (testEvalIdExpr)
import EvalMaybeExpr (testEvalMaybeExpr)
import PostfixExpr (testPostfixExpr)
import Test.QuickCheck
toSingletonLists :: [e] -> [[e]]
toSingletonLists _ = error "TODO"
testToSingletonLists = do
print "******* toSingletonLists"
quickCheck $ counterexample "ints" $
toSingletonLists [ 5, 7, 2 ] == [ [5], [7], [2] ]
quickCheck $ counterexample "chars" $
toSingletonLists [ 'a', 'x', 'd' ] == [ "a", "x", "d" ]
quickCheck $ counterexample "empty" $
toSingletonLists [] == ([] :: [[Int]])
listMap :: (a -> b -> c) -> a -> [b] -> [c]
listMap _ _ _ = error "TODO"
testListMap = do
print "******* listMap"
quickCheck $ counterexample "add" $ listMap (+) 5 [1, 2, 3] == [6, 7, 8]
quickCheck $ counterexample "sub" $ listMap (-) 5 [1, 2, 3] == [4, 3, 2]
quickCheck $ counterexample "mul" $ listMap (*) 5 [1, 2, 3] == [5, 10, 15]
quickCheck $ counterexample "empty" $ listMap (-) 5 [] == []
member :: Eq e => e -> [e] -> Bool
member _ _ = error "TODO"
testMember = do
print "******* member"
quickCheck $ counterexample "ints first" $ member 5 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints last" $ member 2 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints mid" $ member 7 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints fail" $ member 4 [ 5, 7, 2 ] == False
quickCheck $ counterexample "empty" $ member 4 [] == False
selectNApart :: Int -> [e] -> [e]
selectNApart _ _ = error "TODO"
testSelectNApart = do
print "******* selectNApart"
quickCheck $ counterexample "2-apart" $
selectNApart 2 [0..10] == [0, 2, 4, 6, 8, 10]
quickCheck $ counterexample "2-apart chars" $
selectNApart 2 ['a'..'z'] == "acegikmoqsuwy"
quickCheck $ counterexample "3-apart" $
selectNApart 3 [0..20] == [0, 3, 6, 9, 12, 15, 18]
quickCheck $ counterexample "5-apart" $
selectNApart 5 [0..21] == [0, 5, 10, 15, 20]
quickCheck $ counterexample "empty" $ selectNApart 5 ([]::[Int]) == []
------------------------ Functions in Separate Files --------------------
-- #5: 15-points
-- implement the specified function in EvalIntExpr.hs
-- #6: 15-points
-- implement the specified function in EvalIdExpr.hs
-- #7: 20-points
-- implement the specified function in EvalMaybeExpr.hs
-- #8: 20-points
-- implement the specified function in PostfixExpr.hs
allTests = [
(Skip testToSingletonLists),
(Skip testListMap),
(Skip testMember),
(Skip testSelectNApart),
(Skip testEvalIntExpr),
(Skip testEvalIdExpr),
(Skip testEvalMaybeExpr),
(Skip testPostfixExpr)
]
main = do
mapM_ id tests
where
only = onlyTests allTests
tests = if (length only > 0) then only else runTests allTests
For toSingletonLists use the map function to transform a list of elements e into a list of singleton lists [e]. *Must use map*.
Hint: use map with a section.
For listMap return a list containing f a b for each element b in list.
Hint: use the map function or a list comprehension
For member use foldl to implement member e list which returns True if e is a member of list. *Must use foldl*, cannot use elem
Hint: define folding function using a lambda or local let/where definition.
For selectNApart, Given an Int n and a list of elements e, return a list containing the elements of the list at index 0, n, 2n, 3n, 4n, and so on
Hint: use drop
For Tests, Can mark test suites with following test statuses:
Only: run only these tests and other tests marked Only.
Run: run these tests when no tests are marked Only.
Skip: skip these tests.
Ensure that all test suites are set to Run.
|
ff1a1cfa82d0cc684ae98bcec1863fdb
|
{
"intermediate": 0.34335896372795105,
"beginner": 0.45357275009155273,
"expert": 0.20306828618049622
}
|
44,475
|
module Main (main) where
import TestUtils
import EvalIntExpr (testEvalIntExpr)
import EvalIdExpr (testEvalIdExpr)
import EvalMaybeExpr (testEvalMaybeExpr)
import PostfixExpr (testPostfixExpr)
import Test.QuickCheck
---------------------------- toSingletonLists ---------------------------
-- #1: 5-points
-- Use the map function to transform a list of elements e into
-- a list of singleton lists [e]. *Must use map*.
-- Hint: use map with a section.
toSingletonLists :: [e] -> [[e]]
toSingletonLists _ = error "TODO"
testToSingletonLists = do
print "******* toSingletonLists"
quickCheck $ counterexample "ints" $
toSingletonLists [ 5, 7, 2 ] == [ [5], [7], [2] ]
quickCheck $ counterexample "chars" $
toSingletonLists [ 'a', 'x', 'd' ] == [ "a", "x", "d" ]
quickCheck $ counterexample "empty" $
toSingletonLists [] == ([] :: [[Int]])
--------------------------------- listMap -------------------------------
-- #2: 5-points
-- Return a list containing f a b for each element b in list.
-- Hint: use the map function or a list comprehension
listMap :: (a -> b -> c) -> a -> [b] -> [c]
listMap _ _ _ = error "TODO"
testListMap = do
print "******* listMap"
quickCheck $ counterexample "add" $ listMap (+) 5 [1, 2, 3] == [6, 7, 8]
quickCheck $ counterexample "sub" $ listMap (-) 5 [1, 2, 3] == [4, 3, 2]
quickCheck $ counterexample "mul" $ listMap (*) 5 [1, 2, 3] == [5, 10, 15]
quickCheck $ counterexample "empty" $ listMap (-) 5 [] == []
---------------------------------- member -------------------------------
-- #3: 10-points
-- Use foldl to implement member e list which returns True iff
-- e is a member of list. *Must use foldl*, cannot use elem
-- Hint: define folding function using a lambda or local let/where definition;
-- also see definition of member in slides.
member :: Eq e => e -> [e] -> Bool
member _ _ = error "TODO"
testMember = do
print "******* member"
quickCheck $ counterexample "ints first" $ member 5 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints last" $ member 2 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints mid" $ member 7 [ 5, 7, 2 ] == True
quickCheck $ counterexample "ints fail" $ member 4 [ 5, 7, 2 ] == False
quickCheck $ counterexample "empty" $ member 4 [] == False
------------------------------- selectNApart ----------------------------
-- #4: 10-points
-- Given an Int n and a list of elements e, return a list
-- containing the elements of the list at index 0, n, 2n, 3n, 4n, ...
-- Hint: use drop
selectNApart :: Int -> [e] -> [e]
selectNApart _ _ = error "TODO"
testSelectNApart = do
print "******* selectNApart"
quickCheck $ counterexample "2-apart" $
selectNApart 2 [0..10] == [0, 2, 4, 6, 8, 10]
quickCheck $ counterexample "2-apart chars" $
selectNApart 2 ['a'..'z'] == "acegikmoqsuwy"
quickCheck $ counterexample "3-apart" $
selectNApart 3 [0..20] == [0, 3, 6, 9, 12, 15, 18]
quickCheck $ counterexample "5-apart" $
selectNApart 5 [0..21] == [0, 5, 10, 15, 20]
quickCheck $ counterexample "empty" $ selectNApart 5 ([]::[Int]) == []
------------------------ Functions in Separate Files --------------------
-- #5: 15-points
-- implement the specified function in EvalIntExpr.hs
-- #6: 15-points
-- implement the specified function in EvalIdExpr.hs
-- #7: 20-points
-- implement the specified function in EvalMaybeExpr.hs
-- #8: 20-points
-- implement the specified function in PostfixExpr.hs
--------------------------------- Tests ---------------------------------
-- Can mark test suites with following test statuses:
-- Only: run only these tests and other tests marked Only.
-- Run: run these tests when no tests are marked Only.
-- Skip: skip these tests.
allTests = [
(Skip testToSingletonLists),
(Skip testListMap),
(Skip testMember),
(Skip testSelectNApart),
(Skip testEvalIntExpr),
(Skip testEvalIdExpr),
(Skip testEvalMaybeExpr),
(Skip testPostfixExpr)
]
main = do
mapM_ id tests
where
only = onlyTests allTests
tests = if (length only > 0) then only else runTests allTests
|
0e12c58d23c239d306f4804a5a16814f
|
{
"intermediate": 0.3388419449329376,
"beginner": 0.43419554829597473,
"expert": 0.22696255147457123
}
|
44,476
|
-- #5: 15-points
-- implement the specified function in EvalIntExpr.hs
-- #6: 15-points
-- implement the specified function in EvalIdExpr.hs
-- #7: 20-points
-- implement the specified function in EvalMaybeExpr.hs
-- #8: 20-points
-- implement the specified function in PostfixExpr.hs
|
af1ee4fdea5720f41cbe0c3fb05ffc9c
|
{
"intermediate": 0.2747863531112671,
"beginner": 0.5529950857162476,
"expert": 0.17221850156784058
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.